HOM+Namelist+Input+Parameters

Click here to return to main Jetstream Input Parameters page.toc

Jetstream contains both monolithic and predictor-corrector methods for homotopy-based continuation. For more information regarding the theory, implementation, and performance of these algorithms, refer to. To use the homotopy modules:

1) Set **opt_method = 'flowsolve'** and **diablo%nk_global = 0** (predictor-corrector homotopy continuation), **diablo%nk_global = -1** (monolithic homotopy continuation), or **diablo%nk_global = -2** (explicit monolithic homotopy continuation) in the input file; 2) Set **diablo%hom_method** appropriately: 'convex' (default) or 'global' ; 3) Include the homotopy namelist **&homot** at the bottom of the input file; 4) Include any homotopy parameters according to preference.

Note that many solver parameters (diablo%) are not used in this module. Instead, we now use Hom type parameters **(c_hom%** or **g_hom%**) to make the options phase-dependent.

Phases: 1 --> lambda = 1.0; 2 --> 1.0 > lambda > 0.0 3 --> lambda = 0.0 (final phase) = =

HOM% convex_opt
-'diss': Second order dissipation operator (without the pressure switch) as the homotopy function. The extra equation for the RANS formulation is the dissipation-like operator used to stabilize the convective term in the RANS equation (see Michal Osusky's Nashville AIAA paper, on Dr. Zingg's website). -'diss2': This is exactly the same as 'diss' for Euler/NS, but for the RANS equations we use an extended version of the same operator to include the turbulent viscosity. Currently, 'diss2' is far superior to the RANS equations.
 * //Description://** Specifies the continuation function to use.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'diss', 'diss2'
 * //Default Value://** 'diss'
 * //User Notes://**

HOM% nls
HOM% nls% check_relres_glob The checks the relative residual of R at each iterate against the parameter HOM% nls% relres_glob. If it is below that value, we will switch directly to phase 3. This requires an extra L2 norm to be calculated at each iterate. We don't normally use this criterion, it is mainly just for comparison with the original DBC codes which did use this criterion. Default will become .false. at the next merge.
 * //Description://** A flag to determine whether to check the relative residual at globalization.
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% nls% tol_rel_embed Better to keep it on, since turning it off will actually solve the problem more when your predictor step is better, which is not logical.
 * //Description://** A flag to determine whether to take the relative residual relative to the embedding step or the actual predictor point.
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User Notes://**

HOM% nls% use_traceback You can turn this on for difficult flow solves, but expect high cost, and make sure to make nls%max_its(2) large enough so that you can be reasonably sure that failure to meet the tolerance indeed indicates a problem.
 * //Description://** If set to true, the solution will be traced back if the nls fails to converge when max iterations are met. Otherwise, it will just continue on as normal.
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% nls% traceback_max
 * //Description://** Maximum number of traceback iterations if nls%use_traceback is on.
 * //Parameter Type://** Integer
 * //Default Value://** 4

HOM% nls% relres_glob See the description in HOM% nls% check_relres_glob for more info.
 * //Description://** The relative residual that must be met as a requirement at globalization.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 1.d-3
 * //User Notes://**

HOM% nls% fin_strt_relres We check the relative residual (calculated based on the initial flow residual) at globalization (lambda = 0) against this parameter. If it is not lower than this parameter, the predictor step will be repeated with a factor of HOM% nls% fin_strt_red_fac applied to the current steplength and the resulting nonlinear subproblem will be solved to try to get a better estimate. This process is repeated until a suitable initial residual is acquired. Note that the problem becomes increasingly stiff near lambda=0, so this can add significant computation cost to a flow solve. Usually, we use the large default value to essentially turn this off.
 * //Description://** The relative residual at globalization must be less than this to be accepted.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 5.d-1
 * //User Notes://**

HOM% nls% fsrr_tb_max
 * //Description://** If the final starting relative residual tolerance nls%fin_strt_relres is not met, this parameter provides the upper bound on how many times traceback will be attempted.
 * //Parameter Type://** Integer
 * //Range of Acceptable values://** [0, inf]
 * //Default Value://** 10

HOM% nls% traceback_red_fac There is probably no reason to change this from default.
 * //Description://** The traceback phase is activated if problems were encountered at the current subproblem or if nls%fin_strt_relres was not met. In the traceback phase, we repeat the previous predictor iterate with this factor applied to the steplength (so a larger value actually means less reduction).
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 0.5
 * //User Notes://**

HOM% nls% pc_its A typical flow solve will take ~10 predictor steps. If it reaches 50, it is probably stuck above a stagnation point and will never converge.
 * //Description://** Maximum allowable predictor iterations, after which the flow solve will quit.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [1, 400)
 * //Default Value://** 50
 * //User Notes://**

HOM% nls% mh_its
 * //Description://** Maximum allowable iterations for monolithic homotopy, after which the flow solve will quit.
 * //Parameter Type://** integer
 * //Default Value://** 200

HOM% nls% abs_tol(1:3) //**User Notes:**// Note that the convergence criterion for each nonlinear subproblem is that either the relative tolerance __or__ the absolute tolerance is met. While it seems like a good idea in principle to check absolute residuals, in practice we don't really know what these values should be. So, we typically set these small so as not to rely on them, preferring to use the relative residual.
 * //Description://** Absolute tolerance to check if the residual is converged at each phase. Note that the phase 1 and phase 3 values are taken as abs_tol(1)l and abs_tol(3), but the phase 2 value is actually interpolated between abs_tol(1) and abs_tol(2) values.
 * //Parameter Type://** real(3)
 * //Range of Acceptable values://** Should be small
 * //Default Value://** (/ 1E-10, 1E-10, 1E-12 /)

HOM% nls% rel_tol(1:3) //**User Notes:**// rel_tol(1) and rel_tol(2) are taken relative to the starting residual at each particular nonlinear subproblem. For phase 3, the relative residual is taken relative to the starting residual of the flow solve.
 * //Description://** Relative tolerance to check if the residual is converged at each phase. Unlike the absolute tolerance, nls(1), nls(2), and nls(3) do correspond exactly to the relative residual checked at each phase Like abs_tol, this value is also intepolated.
 * //Parameter Type://** real(3)
 * //Range of Acceptable values://** Should be small
 * //Default Value://** (/ 1E-1, 1E-1, 1E-10 /)

HOM% nls% max_its(1:3)
 * //Description://** Maximum allowable nonlinear iterations per subproblem at each phase.
 * //Parameter Type://** integer(3)
 * //Range of Acceptable values://** [1, inf)
 * //Default Value://** (/ 15, 25, 75 /)

HOM% nls% updat_frq(1:3)
 * //Description://** Frequency with which to update both the preconditioner matrix and its ILU factorization.
 * //Parameter Type://** integer(3)
 * //Range of Acceptable values://** [1, large]
 * //Default Value://** (/ 3, 3, 1 /)

HOM% prec
HOM% prec(1:3)% opt //**Parameter Type:**// Character(3) //**Range of Acceptable values:**// 'iluk', 'ilut' //**Default Value:**// (/ 'iluk', 'iluk', 'iluk' /)
 * //Description://** Choice of ILU factorization.

HOM% prec(1:3)% iluk% lev_fil //**Parameter Type:**// Integer(3) //**Range of Acceptable values:**// [0,1,2,3,...] //**Default Value:**// (/ 2, 2, 2 /)
 * //Description://** Fill level for ILUK

HOM% prec(1:3)% ilut //**Parameter Type:**// ilut_opt //**Default Values:**// ilut%lev_fil = (/ 10, 10, 10 /) ilut%bnorm = (/ 2, 2, 2 /) ilut%pivoting = (/ .false., .false., .false. /) ilut%diagcomp = (/ .false., .false., .false. /) ilut%rowave = (/ .false., .false., .false. /) ilut%droptol = (/ 1.d-3, 1.d-3, 1.d-3 /) ilut%adpfactor = (/ 0.d0, 0.d0, 0.d0 /)
 * //Description://** Parameters for ILUT

HOM% ls(1:3)
//**Parameter Type:**// LineSearch //**Default Values:**// ls%on = (/.false., .false., .false. /) ls%damp = (/ 0.9d0, 0.9d0, 0.9d0 /) ls%eta_in = (/ 1.d0, 1.d0, 1.d0 /) ls%eta_min = (/ 0.75d0, 0.75d0, 0.75d0 /) ls%rfac_tol = (/ 1.d0, 1.d0, 1.d0 /)
 * //Description://** Parameters for line search

HOM% l
HOM% l% inewt_s_params
 * //Description://** That's a lower case 'ell', not an upper case 'eye'. The value of lamba below which we will use the matvecs and preconditioner parameters from the inexact Newton phase. For example, if inewt_s_params=0.1, then we can use Frechet matvecs and higher fill level when lambda is below 0.1.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 0.d0

HOM% l% init //**User notes:**// Usually we use the default.
 * //Description://** This is the initial value of lambda.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 1.d0

HOM% l% tol //**User notes:**// Not a critical value; no reason to mess with it.
 * //Description://** A tolerance on lambda. Lambda is considered to be essentially 1 or 0 if it is within this tolerance of it.
 * //Parameter Type://** real
 * //Range of Acceptable values://** should be small
 * //Default Value://** 1.d-12

HOM% scl
HOM% scl% mu Mu-scaling is an extra scaling factor that we apply to the homotopy function G. This parameter affects curvature and hence it affects predictor performance. The value from the input parameter is a front end to this; an appropriate value for mu is acquired from a numerical algorithm based on minimizing the H20norm of d||H||/dlam and hard-coded into the appropriate homotopy module. This value is an extra scaling factor that is applied afterwards. Smaller values tend to reduce the curvature near lambda=0 and increase it near lambda=1 and vice versa. Since the auto-scaling algorithm does not take into account problem stiffness, it may be useful to use mu ~(0.5-0.8). Or, just use the default.
 * //Description://** mu scaling.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User Notes//:**

HOM% scl% mu_turb An experimental extra mu-scaling factor in front of the RANS equation. Changing it from 1 usually causes the solver to fail.
 * //Description://** mu scaling.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User// //Notes//:**

HOM% scl% turb_fac
 * //Description://** Scaling factor for the RANS equations, similar to what is used in Michal's RANS scaling.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d-3

HOM% scl% kappa This parameter is only active when auto-scaling is turned off (HOM% scl% k_auto = .false.), which we typically do not use.
 * //Description://** kappa-scaling value.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User// //Notes//:**

HOM% scl% k_auto Kappa-scaling is applied to the whole equation. It does not affect the predictor performance, but is critical for the orthogonal corrector method and important for steplength adaptation as well since it adjusts the relative scaling between ||dq| and dlambda.
 * //Description://** Turn kappa auto-scaling on?
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User// Notes:**

HOM% scl% k_adapt This will determine the kappa-scaling based on the first nonlinear subproblem requiring at least one nonlinear iteration. This can be used when k_auto is on, in which case it will replace the auto-scaling once it becomes available. I generally don't use this.
 * //Description://** Turn adaptive kappa-scaling on?
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User// Notes:**

HOM% scl% k_angle Degrees. Only active when HOM% scl% k_auto = .true.
 * //Description://** The target angle between the orthogonal corrector and the constant-lambda corrector directions, used in determining the kappa-scaling.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0,90)
 * //Default Value://** 8.d0
 * //User// Notes:**

HOM% scl% k_f_auto Only active when HOM% scl% k_auto = .true.
 * //Description://** Extra factor to multiply auto-acquired kappa by.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User// Notes:**

HOM% scl% k_f_adapt Only active when HOM% scl% k_adapt = .true.
 * //Description://** Extra factor to multiply adaptation-acquired kappa by.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User// Notes:**

HOM% a
HOM% a% m_on This determines acceptable values for mu based on minimizing the H2-norm of d||H||/dlam. The integral is estimated over a variety of mu for a single flow solve by applying a local change of coordinates to lambda. Since the integration is in the lambda direction, the estimate of the integral is inaccurate for large changes in mu, so we limit ourselves to a factor of 10 in each direction per scaling run. The intended use is that we should run this several times, updating mu each time, until it converges. (Should only take a few runs.)
 * //Description://** Is this an auto-scaling run for mu?
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User// Notes:**

HOM% a% m_opt The problem with using the residual is that it is biased by the relative scaling of ||R|| and ||G||, so we typically use the error in the H2-norm minimization described above, and not the residual. Only active when HOM% a% m_on = .true.
 * //Description://** Option for mu auto-scaling algorithm.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'error', 'resid'
 * //Default Value://** 'error'
 * //User// Notes:**

HOM% a% k_on Ideally, mu-scaling has been performed already. This determines acceptable values for kappa based on a target angle between the orthogonal corrector direction and the constant-lambda corrector direction. This should be run for a variety of Ma. We can then do some line-fitting and then hard-code the results into the appropriate homotopy module. (See HOM_C_Diss_Mod for an example of this.)
 * //Description://** Is this and auto-scaling run for kappa?
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User// Notes:**

HOM% a% k_embed
 * //Description://** During an auto-scaling run for kappa, should we over-write the input parameters with embedding parameters?
 * //Parameter Type://** logical
 * //Default Value://** .true.

HOM% sat
HOM% sat% on Note that the linear system will be singular at lambda=1 if the SATs are turned off.
 * //Description://** Should we turn the SATs on?
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User// Notes:**

HOM% sat% opt 1) 'fstrm' - BC's imitate freestream conditions. 2) 'flow' - BC's imitate the flow BC's. Both methods work, but the 'flow' option seems to result in higher curvature for viscous flows.
 * //Description://** Different boundary conditions can be applied to the homotopy function.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'fstrm', 'flow'
 * //Default Value://** 'fstrm'
 * //User// Notes:**

HOM% sat% fac Mostly for debugging.
 * //Description://** We can multiply the SAT terms by a factor
 * //Parameter Type://** real
 * //Range of Acceptable values://** (-inf, inf)
 * //Default Value://** 1.d0
 * //User Notes://**

HOM% sat% sym Works either way, but seems to exhibit slightly lower curvature with it off. NOTE: This should be set to .true. for 2D flow.
 * //Description://** Should symmetry planes still be treated as such?
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% sat% roe_avg
 * //Description://** Turn Roe averaging on?
 * //Parameter Type://** logical
 * //Default Value://** .false.

HOM% h
HOM% h% opt 1) 'none' - Steplength is constant 2) 'adapt' - Applies any steplength adaptation routines, which must be activated individually. By default, ag_a and ag_d are turned on and wj and dhr are turned off. At each predictor step, all active steplength adaptations will be calculated and the most limiting one will be applied. 3) 'hob' - This imitates Hicken/Osusky/Buckley's 2011 AIAA paper. Mostly implemented for debugging and comparative purposes. Note that the scaling of the linear system is different.
 * //Description://** Options for how to modify the steplength.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'none', 'adapt', 'hob'
 * //Default Value://** 'adapt'
 * //User Notes://**

HOM% h% dlam_init This can generally be increased to about 0.2 without convergence problems.
 * //Description://** Change in lambda at the first iteration.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, h%max)
 * //Default Value://** 1.d-1
 * //User Notes://**

HOM% h% min Better to rely on h%dlam_min, and to keep this small, since we really don't have a good idea of what it should be.
 * //Description://** Minimum acceptable value of the steplength.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (h%min, inf)
 * //Default Value://** 1.d-2
 * //User Notes://**

HOM% h% max Better to rely on h%dlam_max, and to keep this large, since we really don't have a good idea of what it should be.
 * //Description://** Maximum acceptable value of the steplength.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (h%min, inf)
 * //Default Value://** 4.d0
 * //User Notes://**

HOM% h% fmin Since we are dividing, this actually sets an upper bound on how much the steplength can __increase__.
 * //Description://** Minimum value to __divide__ the steplength by during adaptation.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 0.5d0
 * //User Notes://**

HOM% h% fmax Since we are dividing, this actually sets an upper bound on how much the steplength can be __reduced by__.
 * //Description://** Maximum value to __divided__ the steplength by during adaptation.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (1, inf)
 * //Default Value://** 2.d0
 * //User Notes://**

HOM% h% dlam_min
 * //Description://** Minimum allowable increase in lambda at each predictor iterate.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, h%dlam_max)
 * //Default Value://** 4.d-2

HOM% h% dlam_max
 * //Description://** Maximum allowable increase in lambda at each predictor iterate.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (h%dlam_min, 1)
 * //Default Value://** 2.5d-1

HOM% h% dlam_max_fin If this number is exceeded, the predictor step is scaled back.
 * //Description://** Maximum allowable change in lambda at the final predictor step (towards globalization).
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 5.d-2
 * //User Notes://**

HOM% ad% ag_d% on Increase the steplength if the initial predictor point was further from the solution than some target value, and decrease otherwise.
 * //Description://** Adaptation of Allgower and Georg (1990) based on asymptotic expansions: distance to the curve.
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User Notes://**

HOM% h% ad% ag_d% auto Unless you know specifically what a good distance to the curve is, you should turn this on.
 * //Description://** Turn on to auto-acquire a target value, which can then be multiplied by the factor h%ad%ag_d%fac.
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User Notes://**

HOM% h% ad% ag_d% fac Greater than 1 will result in larger steplengths and vice versa. Only active if h%ad%ag_d%auto = .true.
 * //Description://** After auto-acquiring the target value for ag_d, we can then multiply it by a factor.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d0
 * //User Notes://**

HOM% h% ad% ag_d% targ Only active if h%ad%ag_d%auto = .false.
 * //Description://** Target value for the distance in ag_d.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 5.d-1
 * //User Notes://**

HOM% h% ad% ag_a% on Essentially, a measure of curvature. This is affected by kappa-scaling. If no corrector iterates were performed this step, then ag_d results in 0 distance, which is not very useful. However, this algorithm still produces something useful. So, it is good to have them both active.
 * //Description://** Turn on Allgower and Georg's (1990) method of asymptotic expansions: angle between successive tangent vectors.
 * //Parameter Type://** logical
 * //Default Value://** .true.
 * //User Notes://**

HOM% h% ad% ag_a% targ Degrees.
 * //Description://** Target angle between successive tangent vectors.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0,90)
 * //Default Value://** 8.d0
 * //User Notes://**

HOM% h% ad% dhr% on This method is based on Newton-Kantorovich theory to try to predict the behaviour of Newton's method. The steplength is adjusted to try to achieve some target number of iterations per nonlinear subproblem. This method seems ideal since it addresses directly the issue of problem stiffness but in practice it suffers from a number of approximation errors resulting in the numerous relaxations that we use.
 * //Description://** Steplength adaptation of Den Heijer and Rheinbodlt (1981).
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% h% ad% dhr% psi It doesn't make much difference which you use.
 * //Description://** Psi are functions that are used in the Kantorovich approximation. There are two available.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** 1,2
 * //Default Value://** 1
 * //User Notes://**

HOM% h% ad% dhr% targ
 * //Description://** Target number of iterations for dhr.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [1,inf)
 * //Default Value://** 5

HOM% h% ad% wgj% on A very simplistic algorithm, where the target is again the number of iterations. Perhaps too simplistic to update the steplength in a useful way.
 * //Description://** Turn on Wales, Gaitonde, Jones' (2012) stplength adaptation.
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% h% ad% wgj% targ
 * //Description://** Target number of iterations for wgj steplength adaptation.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [1, inf)
 * //Default Value://** 5

HOM% h% hob% l_init Input value is assumed to be in Hicken et al. (2011) coordinates.
 * //Description://** For the hob method, lambda does not start at 1.d0 (in fact, it is impossible in the authors' coordinates), so we start from this value.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 15.d0
 * //User Notes://**

HOM% h% hob% beta
 * //Description://** See Hicken et al. (2011) AIAA paper.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.7d0

HOM% p
HOM% p% opt Hgiher order predictors may some day be supported.
 * //Description://** Predictor method.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'euler'
 * //Default Value://** 'euler'
 * //User Notes://**

HOM% p% safety User Notes: Checks the predicted residual against the embedding residual and picks which one is best.
 * //Description://** Turn on if you always want to check the predictor tangent.
 * //Parameter Type://** logical
 * //Default Value://** .true.

HOM% p% prec_up
 * //Description://** Update the preconditioner at each tangent calculation?
 * //Parameter Type://** logical
 * //Default Value://** .true.

HOM% p% check_full I haven't tested this extensively. In the tests I've run, this results in a very large initial residual which is reduced very rapidly, making it hard to determine what the relative tolerances should be.
 * //Description://** This is a fun option the will check the predicted and embedded residual element-wise and replace elements accordingly.
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://**

HOM% p% res_max_i If the residual after a predictor step exceeds the interpolated value, the predictor is scaled back until it is no longer exceeded.
 * //Description://** Maximum allowable starting residual at lambda = 1.d0. Phase 2 values are interpolated from this and p%res_max_i.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d-1
 * //User Notes://**

HOM% p% res_max_f If the residual after a predictor step exceeds the interpolated values, the predictor is scaled back until it is no longer exceeded.
 * //Description://** Maximum allowable starting residual at lambda = 0.d0. Phase 2 values are interpolated from this and p%res_max_f.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, inf)
 * //Default Value://** 1.d-1
 * //User Notes://**

HOM% p% h_reduct_fac
 * //Description://** If the predicted residual is larger than the interpolated value above, we reduce multiply the steplength by this factor and repeat the predictor step.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0, 1)
 * //Default Value://** 0.6d0

HOM% p% h_reduct_max
 * //Description://** If the predicted residual is larger than the interpolated value above, this is the maximum number of times we will try to reduce the steplength.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [1, inf)
 * //Default Value://** 5

HOM% p% t% dlam_min_for_alge Secant method is not very accurate for large step sizes. As the step size decreases, accuracy improves and it is very cheap, so we may want to use it for small step sizes.
 * //Description://** Minimum change in lambda for which we use the algebraic method, less than this will use secant.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0,inf)
 * //Default Value://** 5.d-2
 * //User Notes://**

HOM% p% t% opt 1) 'none' - Embedding algorithm 2) 'alge' - An accurate but expensive algebraic method, requiring the solution to a linear system of equations 3) 'seca' - Secant method; essentailly, first order backwards-differencing.
 * //Description://** Options for calculating the tangent
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'none', 'alge', 'seca'
 * //Default Value://** 'alge'
 * //User Notes://**

HOM% p% t% prec% opt We only need to factor the preconditioner when p%t%opt = 'alge'.
 * //Description://** Choice of preconditioner for the algebraic tangent method.
 * //Parameter Type://** Character
 * //Range of Acceptable values://** 'iluk', 'ilut'
 * //Default Value://** 'iluk'
 * //User Notes://**

HOM% p% t% prec% iluk% lev_fil
 * //Description://** Fill level for the preconditioner.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [0, inf)
 * //Default Value://** 2

HOM% p% t% prec% ilut p%t%prec%ilut%lev_fil = 10 p%t%prec%ilut%bnorm = 2 p%t%prec%ilut%pivoting = .false. p%t%prec%ilut%diagcomp = .false. p%t%prec%ilut%rowave = .false. p%t%prec%ilut%droptol = 1.d-3 p%t%prec%ilut%adpfactor = 0.d0
 * //Description://** Options for ILUT preconditioner for algebraic tangent.
 * //Parameter Type://** ilut_opts
 * //Default Values://**

HOM% p% t% s p%t%s%solver = 'fgmrs' p%t%s%matvec = 'frcht' p%t%s%prec = 'schur' p%t%s%rel_lin_tol = 1.d-2 p%t%s%krylv_size = 40 p%t%s%gcrot_k = 1 p%t%s%krylv_max = 100 p%t%s%sol_init = .true. //**User Notes:**// Active only for HOM%t%opt = 'alge'
 * //Description://** Solver options for the tangent
 * //Parameter Type://** LinSolvOpts
 * //Default Values://**

HOM% c
HOM% c% opt 1) 'none' - lambda is treated as constant. 2) 'proj' - The system is solved in the minimum-norm sense, for the cost of some extra tangent calculations per predictor step.
 * //Description://** Corrector option
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'none', 'proj'
 * //Default Value://** 'none'
 * //User Notes://**

HOM% c% tan_up_frq //**User Notes:**// HOM%c%opt = 'proj' only.
 * //Description://** Period with which to update the tangent.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** (1, inf)
 * //Default Value://** 100 (essentially, off by default)

HOM% c% dlam_max //**User Notes:**// You shouldn't need to rely on this if the kappa-scaling is effective. HOM%c%opt = 'proj' only.
 * //Description://** Maximum allowable value that the corrector step can affect lambda by.
 * //Parameter Type://** real
 * //Range of Acceptable values://** (0,1)
 * //Default Value://** 2.d-2

HOM% c% t% opt HOM%c%opt = 'proj' only. This should be left as 'alge'.
 * //Description://** How to calculate the tangent for the corrector.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'alge'
 * //Default Value://** 'alge'
 * //User Notes://**

HOM% c% t% prec% opt
 * //Description://** Choice of ILU factorization.
 * //Parameter Type://** character
 * //Range of Acceptable values://** 'iluk', 'ilut'
 * //Default Value://** 'iluk'

HOM% c% t% prec% iluk% lev_fil
 * //Description://** Fill level for the preconditioner.
 * //Parameter Type://** integer
 * //Range of Acceptable values://** [1, inf)
 * //Default Value://** 2

HOM% c% t% prec% ilut c%t%prec%ilut%lev_fil = 10 c%t%prec%ilut%bnorm = 2 c%t%prec%ilut%pivoting = .false. c%t%prec%ilut%diagcomp = .false. c%t%prec%ilut%rowave = .false. c%t%prec%ilut%droptol = 1.d-3 c%t%prec%ilut%adpfactor = 0.d0
 * //Description://** ILUT options for the corrector tangent preconditioner.
 * //Parameter Type://** ilut_opts
 * //Range of Acceptable values://** [0, inf)
 * //Default Values://**

HOM% c% t% s c%t%s%solver = 'fgmrs' c%t%s%matvec = 'apprx' c%t%s%prec = 'schur' c%t%s%rel_lin_tol = 1.d-2 c%t%s%krylv_size = 40 c%t%s%gcrot_k = 1 c%t%s%krylv_max = 100 c%t%s%sol_init = .false. HOM%c%opt = 'proj' only.
 * //Description://** Solver options for the corrector tangent.
 * //Parameter Type://** LinSolvOpts
 * //Default Values://**
 * //User Notes://**

HOM% s(1:3)
s(1:3)%solver = (/ 'fgmrs', 'fgmrs', 'fgmrs' /) s(1:3)%matvec = (/ 'apprx', 'frcht', 'frcht' /) s(1:3)%prec = (/ 'schur', 'schur', 'schur' /) s(1:3)%rel_lin_tol = (/ 1.d-2, 1.d-2, 1.d-2 /) s(1:3)%kryl_size = (/ 40, 40, 40 /) s(1:3)%gcrot_k = (/ 1, 1, 1 /) s(1:3)%krylv_max = (/40, 60, 100 /) s(1:3)%sol_init = (/ .false., .false., .false. /)
 * //Description://** Solver options for phases 1, 2, and 3.
 * //Parameter Type://** LinSolvOpts
 * //Default Values://**

HOM% debug
HOM% debug% on
 * //Description://** Turns debugging on.
 * //Parameter Type://** logical
 * //Default Value://** .false.
 * //User Notes://** Don't touch.

HOM% debug% print_lev
 * //Description://** Controls some printing.
 * //Parameter Type://** integer
 * //Default Value://** 11
 * //User Notes://** Don't touch.