double NOX::LineSearch::Utils::Slope::
computeSlope(const Abstract::Vector& dir, const Abstract::Group& grp)
{
if (grp.isGradient())
return(dir.innerProduct(grp.getGradient()));
// Allocate space for vecPtr if necessary
if (Teuchos::is_null(vecPtr))
vecPtr = dir.clone(ShapeCopy);
// v = J * dir
NOX::Abstract::Group::ReturnType status = grp.applyJacobian(dir,*vecPtr);
if (status != NOX::Abstract::Group::Ok)
{
utils.out() << "NOX::LineSearch::Utils::Slope::computeSlope - Unable to apply Jacobian!" << std::endl;
throw "NOX Error";
}
// Check that F exists
if (!grp.isF())
{
utils.out() << "NOX::LineSearch::Utils::Slope::computeSlope - Invalid F" << std::endl;
throw "NOX Error";
}
// Return <v, F> = F' * J * dir = <J'F, dir> = <g, dir>
return(vecPtr->innerProduct(grp.getF()));
}
bool NOX::Direction::SteepestDescent::compute(Abstract::Vector& dir,
Abstract::Group& soln,
const Solver::Generic& solver)
{
NOX::Abstract::Group::ReturnType status;
// Compute F at current solution
status = soln.computeF();
if (status != NOX::Abstract::Group::Ok)
throwError("compute", "Unable to compute F");
// Compute Jacobian at current solution
status = soln.computeJacobian();
if (status != NOX::Abstract::Group::Ok)
throwError("compute", "Unable to compute Jacobian");
// Scale
switch (scaleType) {
case NOX::Direction::SteepestDescent::TwoNorm:
meritFuncPtr->computeGradient(soln, dir);
dir.scale(-1.0/dir.norm());
break;
case NOX::Direction::SteepestDescent::FunctionTwoNorm:
meritFuncPtr->computeGradient(soln, dir);
dir.scale(-1.0/soln.getNormF());
break;
case NOX::Direction::SteepestDescent::QuadMin:
meritFuncPtr->computeQuadraticMinimizer(soln, dir);
break;
case NOX::Direction::SteepestDescent::None:
meritFuncPtr->computeGradient(soln, dir);
dir.scale( -1.0 );
break;
default:
throwError("compute", "Invalid scaleType");
}
return true;
}
bool NOX::LineSearch::SafeguardedStep::compute(Abstract::Group& newGrp,
double& step,
const Abstract::Vector& dir,
const Solver::Generic& s)
{
printOpeningRemarks();
if (useCounter_) {
counter_.incrementNumLineSearches();
counter_.incrementNumNonTrivialLineSearches();
}
invLimits_->reciprocal(*userLimits_);
*scaledUpdate_ = dir;
scaledUpdate_->scale(*invLimits_);
double infNorm = scaledUpdate_->norm(NOX::Abstract::Vector::MaxNorm);
if (infNorm > 1.0)
step = 1.0 / infNorm;
else
step = 1.0;
if (print_.isPrintType(NOX::Utils::Details)) {
print_.out () << "userLimits_:" << std::endl;
userLimits_->print(print_.out());
print_.out () << "scaledUpdate_:" << std::endl;
scaledUpdate_->print(print_.out());
print_.out () << "dir:" << std::endl;
dir.print(print_.out());
print_.out () << "Old Solution:" << std::endl;
newGrp.getX().print(print_.out());
}
if (print_.isPrintType(NOX::Utils::InnerIteration)) {
print_.out () << " computed step = " << step << std::endl;
}
step = std::max(step,lowerStepBound_);
step = std::min(step,upperStepBound_);
if (print_.isPrintType(NOX::Utils::InnerIteration))
print_.out () << " bounded step = " << step << std::endl;
newGrp.computeX(newGrp,dir,step);
if (print_.isPrintType(NOX::Utils::Details)) {
// reuse invLimits_, will be reset above
invLimits_->update(step,dir,0.0);
print_.out () << "Final Step Scaled Update:" << std::endl;
invLimits_->print(print_.out());
print_.out () << "New Solution:" << std::endl;
newGrp.getX().print(print_.out());
}
if (useCounter_)
counter_.setValues(*paramsPtr_);
return true;
}
double NOX::LineSearch::Utils::Slope::
computeSlopeWithOutJac(const Abstract::Vector& dir,
const Abstract::Group& grp)
{
// Allocate space for vecPtr and grpPtr if necessary
if (Teuchos::is_null(vecPtr))
vecPtr = dir.clone(ShapeCopy);
if (Teuchos::is_null(grpPtr))
grpPtr = grp.clone(ShapeCopy);
// Check that F exists
if (!grp.isF())
{
utils.out() << "NOX::LineSearch::Utils::Slope::computeSlope - Invalid F" << std::endl;
throw "NOX Error";
}
// Compute the perturbation parameter
double lambda = 1.0e-6;
double denominator = dir.norm();
// Don't divide by zero
if (denominator == 0.0)
denominator = 1.0;
double eta = lambda * (lambda + grp.getX().norm() / denominator);
// Don't divide by zero
if (eta == 0.0)
eta = 1.0e-6;
// Perturb the solution vector
vecPtr->update(eta, dir, 1.0, grp.getX(), 0.0);
// Compute the new F --> F(x + eta * dir)
grpPtr->setX(*vecPtr);
grpPtr->computeF();
// Compute Js = (F(x + eta * dir) - F(x))/eta
vecPtr->update(-1.0/eta, grp.getF(), 1.0/eta, grpPtr->getF(), 0.0);
return(vecPtr->innerProduct(grp.getF()));
}
void NOX::Direction::QuasiNewton::MemoryUnit::reset(const Abstract::Vector& newX,
const Abstract::Vector& oldX,
const Abstract::Vector& newG,
const Abstract::Vector& oldG)
{
if (Teuchos::is_null(sPtr))
{
sPtr = newX.clone(ShapeCopy);
yPtr = newX.clone(ShapeCopy);
}
sPtr->update(1.0, newX, -1.0, oldX, 0.0);
yPtr->update(1.0, newG, -1.0, oldG, 0.0);
sdotyValue = sPtr->innerProduct(*yPtr);
ydotyValue = yPtr->innerProduct(*yPtr);
rhoValue = 1.0 / sdotyValue;
}
bool NonlinearCG::compute(Abstract::Vector& dir, Abstract::Group& soln,
const Solver::Generic& solver)
{
Abstract::Group::ReturnType ok;
// Initialize vector memory if haven't already
if(Teuchos::is_null(oldDirPtr))
oldDirPtr = soln.getX().clone(NOX::ShapeCopy);
if(Teuchos::is_null(oldDescentDirPtr))
oldDescentDirPtr = soln.getX().clone(NOX::ShapeCopy);
// These are conditionally created
if(Teuchos::is_null(diffVecPtr) && usePRbeta)
diffVecPtr = soln.getX().clone(NOX::ShapeCopy);
if(Teuchos::is_null(tmpVecPtr) && doPrecondition)
tmpVecPtr = soln.getX().clone(NOX::ShapeCopy);
// Get a reference to the old solution group (const)
oldSolnPtr = &solver.getPreviousSolutionGroup();
const Abstract::Group& oldSoln(*oldSolnPtr);
niter = solver.getNumIterations();
// Construct Residual and precondition (if desired) as first step in
// getting new search direction
ok = soln.computeF();
if (ok != Abstract::Group::Ok)
{
if (utils->isPrintType(Utils::Warning))
utils->out() << "NOX::Direction::NonlinearCG::compute - Unable to compute F." << std::endl;
return false;
}
dir = soln.getF();
if(doPrecondition)
{
if(!soln.isJacobian())
ok = soln.computeJacobian();
if (ok != Abstract::Group::Ok)
{
if (utils->isPrintType(Utils::Warning))
utils->out() << "NOX::Direction::NonlinearCG::compute - Unable to compute Jacobian." << std::endl;
return false;
}
*tmpVecPtr = dir;
ok = soln.applyRightPreconditioning(false, paramsPtr->sublist("Nonlinear CG").sublist("Linear Solver"), *tmpVecPtr, dir);
if( ok != Abstract::Group::Ok )
{
if (utils->isPrintType(Utils::Warning))
utils->out() << "NOX::Direction::NonlinearCG::compute - Unable to apply Right Preconditioner." << std::endl;
return false;
}
}
dir.scale(-1.0);
// Orthogonalize using previous search direction
beta = 0.0;
if( niter!=0 )
{
// Two choices (for now) for orthogonalizing descent direction with previous:
if( usePRbeta )
{
// Polak-Ribiere beta
*diffVecPtr = dir;
diffVecPtr->update(-1.0, *oldDescentDirPtr, 1.0);
double denominator = oldDescentDirPtr->innerProduct(oldSoln.getF());
beta = diffVecPtr->innerProduct(soln.getF()) / denominator;
// Constrain beta >= 0
if( beta < 0.0 )
{
if (utils->isPrintType(Utils::OuterIteration))
utils->out() << "BETA < 0, (" << beta << ") --> Resetting to zero" << std::endl;
beta = 0.0;
}
}
else
{
// Fletcher-Reeves beta
double denominator = oldDescentDirPtr->innerProduct(oldSoln.getF());
beta = dir.innerProduct(soln.getF()) / denominator;
}
// Allow for restart after specified number of nonlinear iterations
if( (niter % restartFrequency) == 0 )
{
if( utils->isPrintType(Utils::OuterIteration) )
utils->out() << "Resetting beta --> 0" << std::endl;
beta = 0 ; // Restart with Steepest Descent direction
}
} // niter != 0
*oldDescentDirPtr = dir;
dir.update(beta, *oldDirPtr, 1.0);
*oldDirPtr = dir;
return (ok == Abstract::Group::Ok);
}