proteus.StepControl module

A class hierarchy for methods of controlling the step size

class proteus.StepControl.SC_base(model, nOptions)

Bases: object

A simple fixed time stepping controller with no error/stability control and reduction by 1/2 in case of solver failures.

setInitialGuess(uList, rList)

set_dt_allLevels()

resetSolution()

saveSolution()

retryStep_solverFailure()

retryStep_errorFailure()

stepExact_model(tOut)

choose_dt_model()

initialize_dt_model(t0, tOut)

updateSubstep()

setSubsteps(tList)

default controller just sets substeps to be input list without regard to time integration scheme

initializeTimeHistory()

updateTimeHistory(resetFromDOF=False)

errorFailure()

writeSolverStatisticsForStep()

record some relevant time step and solver statistics uses finest level to get this information called before updating t_model –> t_model_last etc

proteus.StepControl.FixedStep

alias of proteus.StepControl.SC_base

class proteus.StepControl.Newton_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

Same as SC_base but since there is no dt we have not way to retry

retryStep_solverFailure()

retryStep_errorFailure()

class proteus.StepControl.PsiTCtte_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

stepExact_model(tOut)

initialize_dt_model(t0, tOut)

setInitialGuess(uList, rList)

updateSubstep()

choose_dt_model()

class proteus.StepControl.Osher_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

stepExact_model(tOut)

initialize_dt_model(t0, tOut)

updateSubstep()

choose_dt_model()

class proteus.StepControl.Osher_PsiTC_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

stepExact_model(tOut)

initialize_dt_model(t0, tOut)

updateSubstep()

choose_dt_model()

class proteus.StepControl.Osher_PsiTC_controller2(model, nOptions)

Bases: proteus.StepControl.SC_base

stepExact_model(tOut)

initialize_dt_model(t0, tOut)

updateSubstep()

choose_dt_model()

class proteus.StepControl.Min_dt_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

initialize_dt_model(t0, tOut)

choose_dt_model()

setSubsteps(tList)

allow time intergration scheme to pick ‘substeps’ for interval. This would be useful for multistage schemes

class proteus.StepControl.Min_dt_RKcontroller(model, nOptions)

Bases: proteus.StepControl.SC_base

initialize_dt_model(t0, tOut)

choose_dt_model()

stepExact_model(tOut)

setSubsteps(tList)

allow time intergration scheme to pick ‘substeps’ for interval. this is necessary for RK since stages are substeps

class proteus.StepControl.Min_dt_cfl_controller(model, nOptions)

Bases: proteus.StepControl.Min_dt_controller

initialize_dt_model(t0, tOut)

choose_dt_model()

updateTimeHistory(resetFromDOF=False)

class proteus.StepControl.Min_dt_controller_FCT(model, nOptions)

Bases: proteus.StepControl.Min_dt_controller

controller try and implement a piece of FCT methodology where first step is a low order solution and the next step corrects is

initialize_dt_model(t0, tOut)

setInitialGuess(uList, rList)

errorFailure()

retryStep_errorFailure()

class proteus.StepControl.FLCBDF_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

setInitialGuess(uList, rList)

set_dt_allLevels()

retryStep_solverFailure()

retryStep_errorFailure()

errorFailure()

initialize_dt_model(t0, tOut)

choose_dt_model()

class proteus.StepControl.FLCBDF_controller_sys(model, nOptions)

Bases: proteus.StepControl.FLCBDF_controller

retryStep_solverFailure()

retryStep_errorFailure()

class proteus.StepControl.HeuristicNL_dt_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

Classical Heuristic step controller that picks time step based on threshholds in nonlinear solver iterations

if nnl < nonlinearIterationsFloor:

dt *= dtNLgrowFactor

else if nnl > nonlinearIterationsCeil:

dt *= dtNLreduceFactor

end

if the nonlinear solver fails, the time step is modified using

dt *= dtNLfailureReduceFactor

Also includes simple linear predictor for initial guess

y^{n+1,p} = y^{n} + (y^{n}-y^{n-1})/(Delta t^{n})(t - t^{n-1})

setInitialGuess(uList, rList)

saveSolution()

retryStep_solverFailure()

nonlinear solver failure just use cut by dtNLfailureReduceFactor

retryStep_errorFailure()

choose_dt_model()

choose dt after successful step use finest level to pick for now

updateTimeHistory(resetFromDOF=False)

errorFailure()

class proteus.StepControl.GustafssonFullNewton_dt_controller(model, nOptions)

Bases: proteus.StepControl.SC_base

Try version of basic Gustafsson and Soederlind 97 time step selection strategy

that accounts for nonlinear solver performance assuming a full Newton nonlinear solver

Also includes error control based on classical “deadbeat” control Right now, decisions based on finest level solve

input: dt_prev output: dt

get time step estimate based on temporal error –> dt_e get convergence rate estimate from nonlinear solver –> a get number of iterations from nonlinear solver –> nnl

if nonlinear solver converges

r_a = phi(a_ref/a) r_a = min(r_a_max,max(r_a,r_a_min))

else

if a_ref < a #convergence rate ok but took too many iterations anyway

r_a = phi(nnl_ref/nnl)

else

r_a = phi(a_ref/a)

# r_a = min(r_a_max,max(r_a,r_a_min))

#

dt = min(dt_e,r_a dt_prev)

Here,

a_ref – target convergence rate nnl_ref – target number of nonlinear iterations r_a_max – max growth rate r_a_min – min growth rate

phi – limiter function, defaut is phi(x) = x

Also includes simple linear predictor for initial guess

y^{n+1,p} = y^{n} + (y^{n}-y^{n-1})/(Delta t^{n})(t - t^{n-1})

setInitialGuess(uList, rList)

for now ignore time integrations predictor since that is for m and not u by default …

saveSolution()

retryStep_solverFailure()

nonlinear solver failure .. todo:

make sure predictor gets called again after this to get error
estimate correct for next solve

choose_dt_solverFailure(dt)

choose_dt_solverSuccess(dt)

retryStep_errorFailure()

figure out where to make sure that predictor gets called by timeIntegration to setup error estimates

estimateError()

choose_dt_fromError(dtIn)

pick dt based on error considerations, assumes error is already calculated

initialize_dt_model(t0, tOut)

TODO: Figure out good strategy for picking initial dt since we don’t necessarily want

time integration to be responsible for this right now

choose_dt_model()

choose dt after successful step use finest level to pick for now

assumes estimateError already called in errorFailure

updateTimeHistory(resetFromDOF=False)

errorFailure()

phi(x)

set_dt_allLevels()

stepExact_model(tOut)