double
LOCA::Extended::Vector::norm(NormType type) const
{
double n = 0.0;
double nv;
switch (type) {
case NOX::Abstract::Vector::MaxNorm:
for (unsigned int i=0; i<vectorPtrs.size(); i++)
n = NOX_MAX(n, vectorPtrs[i]->norm(type));
n = NOX_MAX(n, scalarsPtr->normInf());
break;
case NOX::Abstract::Vector::OneNorm:
for (unsigned int i=0; i<vectorPtrs.size(); i++)
n += vectorPtrs[i]->norm(type);
n += scalarsPtr->normOne();
break;
case NOX::Abstract::Vector::TwoNorm:
default:
for (unsigned int i=0; i<vectorPtrs.size(); i++) {
nv = vectorPtrs[i]->norm(type);
n += nv*nv;
}
nv = scalarsPtr->normFrobenius();
n += nv*nv;
n = sqrt(n);
break;
}
return n;
}
// **************************************************************************
// *** computeForcingTerm
// **************************************************************************
double NOX::Direction::Utils::InexactNewton::
computeForcingTerm(const NOX::Abstract::Group& soln,
const NOX::Abstract::Group& oldsoln,
int niter,
const NOX::Solver::Generic& solver,
double eta_last)
{
const std::string indent = " ";
if (forcingTermMethod == Constant) {
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "CALCULATING FORCING TERM" << std::endl;
printing->out() << indent << "Method: Constant" << std::endl;
printing->out() << indent << "Forcing Term: " << eta_k << std::endl;
}
if (setTolerance)
paramsPtr->sublist(directionMethod).sublist("Linear Solver").
set("Tolerance", eta_k);
return eta_k;
}
// Get linear solver current tolerance.
// NOTE: These values are changing at each nonlinear iteration and
// must either be updated from the parameter list each time a compute
// is called or supplied during the function call!
double eta_km1 = 0.0;
if (eta_last < 0.0)
eta_km1 = paramsPtr->sublist(directionMethod).
sublist("Linear Solver").get("Tolerance", 0.0);
else
eta_km1 = eta_last;
// Tolerance may have been adjusted in a line search algorithm so we
// have to account for this.
const NOX::Solver::LineSearchBased* solverPtr = 0;
solverPtr = dynamic_cast<const NOX::Solver::LineSearchBased*>(&solver);
if (solverPtr != 0) {
eta_km1 = 1.0 - solverPtr->getStepSize() * (1.0 - eta_km1);
}
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "CALCULATING FORCING TERM" << std::endl;
printing->out() << indent << "Method: " << method << std::endl;
}
if (forcingTermMethod == Type1) {
if (niter == 0) {
eta_k = eta_initial;
}
else {
// Return norm of predicted F
// do NOT use the following lines!! This does NOT account for
// line search step length taken.
// const double normpredf = 0.0;
// oldsoln.getNormLastLinearSolveResidual(normpredf);
// Create a new vector to be the predicted RHS
if (Teuchos::is_null(predRhs)) {
predRhs = oldsoln.getF().clone(ShapeCopy);
}
if (Teuchos::is_null(stepDir)) {
stepDir = oldsoln.getF().clone(ShapeCopy);
}
// stepDir = X - oldX (i.e., the step times the direction)
stepDir->update(1.0, soln.getX(), -1.0, oldsoln.getX(), 0);
// Compute predRhs = Jacobian * step * dir
if (!(oldsoln.isJacobian())) {
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << "WARNING: NOX::InexactNewtonUtils::resetForcingTerm() - "
<< "Jacobian is out of date! Recomputing Jacobian." << std::endl;
}
const_cast<NOX::Abstract::Group&>(oldsoln).computeJacobian();
}
oldsoln.applyJacobian(*stepDir, *predRhs);
// Compute predRhs = RHSVector + predRhs (this is the predicted RHS)
predRhs->update(1.0, oldsoln.getF(), 1.0);
// Compute the norms
double normpredf = predRhs->norm();
double normf = soln.getNormF();
double normoldf = oldsoln.getNormF();
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "Forcing Term Norm: Using L-2 Norm."
<< std::endl;
}
// Compute forcing term
eta_k = fabs(normf - normpredf) / normoldf;
// Some output
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "Residual Norm k-1 = "
<< normoldf << "\n";
printing->out() << indent << "Residual Norm Linear Model k = "
<< normpredf << "\n";
printing->out() << indent << "Residual Norm k = " << normf << "\n";
printing->out() << indent << "Calculated eta_k (pre-bounds) = " << eta_k << std::endl;
}
// Impose safeguard and constraints ...
const double tmp = (1.0 + sqrt(5.0)) / 2.0;
const double eta_km1_alpha = pow(eta_km1, tmp);
if (eta_km1_alpha > 0.1)
eta_k = NOX_MAX(eta_k, eta_km1_alpha);
eta_k = NOX_MAX(eta_k, eta_min);
eta_k = NOX_MIN(eta_max, eta_k);
}
}
else if (forcingTermMethod == Type2) {
if (niter == 0) {
eta_k = eta_initial;
}
else {
double normf = soln.getNormF();
double normoldf = oldsoln.getNormF();
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "Forcing Term Norm: Using L-2 Norm."
<< std::endl;
}
const double residual_ratio = normf / normoldf;
eta_k = gamma * pow(residual_ratio, alpha);
// Some output
if (printing->isPrintType(NOX::Utils::Details)) {
printing->out() << indent << "Residual Norm k-1 = "
<< normoldf << "\n";
printing->out() << indent << "Residual Norm k = "
<< normf << "\n";
printing->out() << indent << "Calculated eta_k (pre-bounds) = "
<< eta_k << std::endl;
}
// Impose safeguard and constraints ...
const double eta_k_alpha = gamma * pow(eta_km1, alpha);
if (eta_k_alpha > 0.1)
eta_k = NOX_MAX(eta_k, eta_k_alpha);
eta_k = NOX_MAX(eta_k, eta_min);
eta_k = NOX_MIN(eta_max, eta_k);
}
}
// Set the new linear solver tolerance
if (setTolerance)
paramsPtr->sublist(directionMethod).sublist("Linear Solver").
set("Tolerance", eta_k);
if (printing->isPrintType(NOX::Utils::Details))
printing->out() << indent << "Forcing Term: " << eta_k << std::endl;
return eta_k;
}
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;
}
