NOX::Abstract::Group::ReturnType
LOCA::StepSize::Adaptive::computeStepSize(
LOCA::MultiContinuation::AbstractStrategy& curGroup,
const LOCA::MultiContinuation::ExtendedVector& predictor,
const NOX::Solver::Generic& solver,
const LOCA::Abstract::Iterator::StepStatus& stepStatus,
const LOCA::Stepper& stepper,
double& stepSize)
{
// If this is the first step, set step size to initial value
if (isFirstStep) {
double dpds = predictor.getScalar(0);
if (dpds != 0.0) {
LOCA::StepSize::Constant::startStepSize /= dpds;
LOCA::StepSize::Constant::maxStepSize /= dpds;
LOCA::StepSize::Constant::minStepSize /= dpds;
}
LOCA::StepSize::Constant::isFirstStep = false;
stepSize = LOCA::StepSize::Constant::startStepSize;
prevStepSize = 0.0;
}
else {
// A failed nonlinear solve cuts the step size in half
if (stepStatus == LOCA::Abstract::Iterator::Unsuccessful) {
stepSize *= LOCA::StepSize::Constant::failedFactor;
}
else {
double ds_ratio = curGroup.getStepSizeScaleFactor();
LOCA::StepSize::Constant::startStepSize *= ds_ratio;
LOCA::StepSize::Constant::maxStepSize *= ds_ratio;
LOCA::StepSize::Constant::minStepSize *= ds_ratio;
// Get number of nonlinear iterations in last step
double numNonlinearSteps =
static_cast<double>(solver.getNumIterations());
// Save successful stepsize as previous
prevStepSize = stepSize;
// adapive step size control
double factor = (maxNonlinearSteps - numNonlinearSteps)
/ (maxNonlinearSteps);
stepSize *= (1.0 + agrValue * factor * factor);
stepSize *= ds_ratio;
}
}
// Clip step size to be within prescribed bounds
NOX::Abstract::Group::ReturnType res = clipStepSize(stepSize);
return res;
}
void
LOCA::MultiContinuation::ExtendedGroup::projectToDraw(
const LOCA::MultiContinuation::ExtendedVector& x,
double *px) const
{
// first numParams components are the parameters
for (int i=0; i<numParams; i++)
px[i] = x.getScalar(i);
// fill remaining solution components
grpPtr->projectToDraw(*x.getXVec(), px+numParams);
}
NOX::Abstract::Group::ReturnType
LOCA::StepSize::Constant::computeStepSize(
LOCA::MultiContinuation::AbstractStrategy& curGroup,
const LOCA::MultiContinuation::ExtendedVector& predictor,
const NOX::Solver::Generic& solver,
const LOCA::Abstract::Iterator::StepStatus& stepStatus,
// const LOCA::Stepper& stepper,
const LOCA::Abstract::Iterator& stepper,
double& stepSize)
{
// If this is the first step, set step size to initial value adjusted
// to predicted change in parameter
if (isFirstStep) {
double dpds = predictor.getScalar(0);
if (dpds != 0.0) {
startStepSize /= dpds;
maxStepSize /= dpds;
minStepSize /= dpds;
}
stepSize = startStepSize;
isFirstStep = false;
prevStepSize = 0.0;
}
else {
// Step size remains constant, unless...
// A failed nonlinear solve cuts the step size by failedFactor
if (stepStatus == LOCA::Abstract::Iterator::Unsuccessful) {
stepSize *= failedFactor;
}
else {
double ds_ratio = curGroup.getStepSizeScaleFactor();
startStepSize *= ds_ratio;
maxStepSize *= ds_ratio;
minStepSize *= ds_ratio;
prevStepSize = stepSize;
stepSize *= ds_ratio;
// For constant step size, the step size may still have been
// reduced by a solver failure. We then increase the step size
// by a factor of cube-root-2 until back to the original step size
if (stepSize != startStepSize) {
stepSize *= successFactor;
if (startStepSize > 0.0)
stepSize = NOX_MIN(stepSize, startStepSize);
else
stepSize = NOX_MAX(stepSize, startStepSize);
}
}
}
// Clip step size to be within prescribed bounds
NOX::Abstract::Group::ReturnType res = clipStepSize(stepSize);
return res;
}