void
GenericEpetraProblem::outputResults(const NOX::Solver::Generic& solver,
Teuchos::ParameterList& printParams)
{
// Output the parameter list
NOX::Utils utils(printParams);
if (utils.isPrintType(NOX::Utils::Parameters)) {
cout << endl << "Final Parameters" << endl
<< "****************" << endl;
solver.getList().print(cout);
cout << endl;
}
// Get the Epetra_Vector with the final solution from the solver
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver.getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>
(finalGroup.getX())).getEpetraVector();
// Print solution
char file_name[25];
FILE *ifp;
int NumMyElements = finalSolution.Map().NumMyElements();
(void) sprintf(file_name, "output.%d",finalSolution.Map().Comm().MyPID());
ifp = fopen(file_name, "w");
for (int i=0; i<NumMyElements; i++)
fprintf(ifp,"%d %E\n",finalSolution.Map().MinMyGID()+i,finalSolution[i]);
fclose(ifp);
}
void
BroydenOperator::runPostIterate( const NOX::Solver::Generic & solver)
{
// Get and update using the solver object.
if( solver.getNumIterations() > 0 )
{
// To consistently compute changes to the step and the yield, eg effects of
// linesearch or other globalizations, we need to get and subtract the old and
// new solution states and corresponding residuals
const Abstract::Group & oldSolnGrp = solver.getPreviousSolutionGroup();
const Abstract::Group & solnGrp = solver.getSolutionGroup();
// Set the Step vector
*workVec = solnGrp.getX();
workVec->update(-1.0, oldSolnGrp.getX(), 1.0);
setStepVector( *workVec );
// Set the Yield vector
*workVec = solnGrp.getF();
workVec->update(-1.0, oldSolnGrp.getF(), 1.0);
setYieldVector( *workVec );
// Use of these updated vectors occurs when computeJacobian or computePreconditioner
// gets called
}
prePostOperator.runPostIterate( solver );
return;
}
NOX::StatusTest::StatusType
N_NLS_NOX::Stagnation::checkStatus(const NOX::Solver::Generic& problem)
{
status = NOX::StatusTest::Unconverged;
// First time through we don't do anything but reset the counters
int niters = problem.getNumIterations();
if (niters == 0) {
numSteps = 0;
lastIteration = 0;
convRate = 1.0;
//minConvRate = 1.0; // Don't reset this. Xyce solver never does.
normFInit = problem.getSolutionGroup().getNormF();
return NOX::StatusTest::Unconverged;
}
// Make sure we have not already counted the last nonlinear iteration.
// This protects against multiple calls to checkStatus() in between
// nonlinear iterations.
bool isCounted = false;
if (niters == lastIteration) {
isCounted = true;
}
else
lastIteration = niters;
// Compute the convergenc rate and set counter appropriately
if (!isCounted) {
convRate = problem.getSolutionGroup().getNormF() /
problem.getPreviousSolutionGroup().getNormF();
if (fabs(convRate - 1.0) <= tolerance) {
if ((numSteps == 0) || (convRate < minConvRate))
minConvRate = convRate;
++numSteps ;
}
else
numSteps = 0;
}
if (numSteps >= maxSteps) {
double initConvRate = problem.getSolutionGroup().getNormF()/normFInit;
if ((initConvRate <= 0.9) && (minConvRate <= 1.0)) {
status = NOX::StatusTest::Converged;
}
else
status = NOX::StatusTest::Failed;
}
return status;
}
bool NOX::Direction::Newton::compute(NOX::Abstract::Vector& dir,
NOX::Abstract::Group& soln,
const NOX::Solver::Generic& solver)
{
NOX::Abstract::Group::ReturnType status;
// Compute F at current solution.
status = soln.computeF();
if (status != NOX::Abstract::Group::Ok)
NOX::Direction::Newton::throwError("compute", "Unable to compute F");
// Reset the linear solver tolerance.
if (useAdjustableForcingTerm) {
resetForcingTerm(soln, solver.getPreviousSolutionGroup(),
solver.getNumIterations(), solver);
}
else {
if (utils->isPrintType(Utils::Details)) {
utils->out() << " CALCULATING FORCING TERM" << endl;
utils->out() << " Method: Constant" << endl;
utils->out() << " Forcing Term: " << eta_k << endl;
}
}
// Compute Jacobian at current solution.
status = soln.computeJacobian();
if (status != NOX::Abstract::Group::Ok)
NOX::Direction::Newton::throwError("compute", "Unable to compute Jacobian");
// Compute the Newton direction
status = soln.computeNewton(paramsPtr->sublist("Newton").sublist("Linear Solver"));
// It didn't converge, but maybe we can recover.
if ((status != NOX::Abstract::Group::Ok) &&
(doRescue == false)) {
NOX::Direction::Newton::throwError("compute",
"Unable to solve Newton system");
}
else if ((status != NOX::Abstract::Group::Ok) &&
(doRescue == true)) {
if (utils->isPrintType(NOX::Utils::Warning))
utils->out() << "WARNING: NOX::Direction::Newton::compute() - Linear solve "
<< "failed to achieve convergence - using the step anyway "
<< "since \"Rescue Bad Newton Solve\" is true " << endl;
}
// Set search direction.
dir = soln.getNewton();
return true;
}
void runPostSolve(const NOX::Solver::Generic& solver)
{
TEUCHOS_ASSERT(m_lof!=Teuchos::null);
const NOX::Abstract::Vector& x = solver.getSolutionGroup().getX();
const NOX::Thyra::Vector* n_th_x = dynamic_cast<const NOX::Thyra::Vector*>(&x);
TEUCHOS_TEST_FOR_EXCEPTION(n_th_x == NULL, std::runtime_error, "Failed to dynamic_cast to NOX::Thyra::Vector!")
Teuchos::RCP<const Thyra::VectorBase<double> > th_x = n_th_x->getThyraRCPVector();
// initialize the assembly container
panzer::AssemblyEngineInArgs ae_inargs;
ae_inargs.container_ = m_lof->buildLinearObjContainer();
ae_inargs.ghostedContainer_ = m_lof->buildGhostedLinearObjContainer();
ae_inargs.alpha = 0.0;
ae_inargs.beta = 1.0;
ae_inargs.evaluate_transient_terms = false;
// initialize the ghosted container
m_lof->initializeGhostedContainer(panzer::LinearObjContainer::X,*ae_inargs.ghostedContainer_);
{
// initialize the x vector
const Teuchos::RCP<panzer::ThyraObjContainer<double> > thyraContainer
= Teuchos::rcp_dynamic_cast<panzer::ThyraObjContainer<double> >(ae_inargs.container_,true);
thyraContainer->set_x_th(Teuchos::rcp_const_cast<Thyra::VectorBase<double> >(th_x));
}
m_response_library->addResponsesToInArgs<panzer::Traits::Residual>(ae_inargs);
m_response_library->evaluate<panzer::Traits::Residual>(ae_inargs);
// write to disk
m_mesh->writeToExodus(0.0);
}
NOX::StatusTest::StatusType
LOCA::Continuation::StatusTest::ParameterResidualNorm::checkStatus(
const NOX::Solver::Generic& problem)
{
// Get solution groups from solver
const NOX::Abstract::Group& soln = problem.getSolutionGroup();
// Cast soln group to continuation group (for parameter step)
const LOCA::Continuation::ExtendedGroup* conGroupPtr =
dynamic_cast<const LOCA::Continuation::ExtendedGroup*>(&soln);
// Check that group is a continuation group, return converged if not
if (conGroupPtr == NULL) {
paramResidualNorm = 0.0;
return NOX::StatusTest::Converged;
}
// Get residual vector
const LOCA::Continuation::ExtendedVector& f =
dynamic_cast<const LOCA::Continuation::ExtendedVector&>(soln.getF());
paramResidualNorm =
fabs(f.getParam()) / (rtol*fabs(conGroupPtr->getStepSize()) + atol);
if (paramResidualNorm < tol)
status = NOX::StatusTest::Converged;
else
status = NOX::StatusTest::Unconverged;
return status;
}
NOX::StatusTest::StatusType
LOCA::Bifurcation::PitchforkBord::StatusTest::ParameterUpdateNorm::checkStatus(
const NOX::Solver::Generic& problem)
{
// Get solution groups from solver
const NOX::Abstract::Group& soln = problem.getSolutionGroup();
const NOX::Abstract::Group& oldsoln = problem.getPreviousSolutionGroup();
// Cast soln group to pitchfork group
const LOCA::Bifurcation::PitchforkBord::ExtendedGroup* pfGroupPtr =
dynamic_cast<const LOCA::Bifurcation::PitchforkBord::ExtendedGroup*>(&soln);
// Check that group is a pitchfork group, return converged if not
if (pfGroupPtr == NULL) {
paramUpdateNorm = 0.0;
return NOX::StatusTest::Converged;
}
// Get solution vectors
const LOCA::Bifurcation::PitchforkBord::ExtendedVector& x =
dynamic_cast<const LOCA::Bifurcation::PitchforkBord::ExtendedVector&>(soln.getX());
const LOCA::Bifurcation::PitchforkBord::ExtendedVector& xold =
dynamic_cast<const LOCA::Bifurcation::PitchforkBord::ExtendedVector&>(oldsoln.getX());
// On the first iteration, the old and current solution are the same so
// we should return the test as unconverged until there is a valid
// old solution (i.e. the number of iterations is greater than zero).
int niters = problem.getNumIterations();
if (niters == 0)
{
paramUpdateNorm = 1.0e+12;
status = NOX::StatusTest::Unconverged;
return status;
}
paramUpdateNorm =
fabs(x.getBifParam() - xold.getBifParam()) / (rtol*fabs(x.getBifParam()) + atol);
if (paramUpdateNorm < tol)
status = NOX::StatusTest::Converged;
else
status = NOX::StatusTest::Unconverged;
return status;
}
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;
}
bool
NOX::Solver::TensorBased::implementGlobalStrategy(NOX::Abstract::Group& newGrp,
double& in_stepSize,
const NOX::Solver::Generic& s)
{
bool ok;
counter.incrementNumLineSearches();
isNewtonDirection = false;
NOX::Abstract::Vector& searchDirection = *tensorVecPtr;
if ((counter.getNumLineSearches() == 1) || (lsType == Newton))
{
isNewtonDirection = true;
searchDirection = *newtonVecPtr;
}
// Do line search and compute new soln.
if ((lsType != Dual) || (isNewtonDirection))
ok = performLinesearch(newGrp, in_stepSize, searchDirection, s);
else if (lsType == Dual)
{
double fTensor = 0.0;
double fNew = 0.0;
double tensorStep = 1.0;
bool isTensorDescent = false;
const Abstract::Group& oldGrp = s.getPreviousSolutionGroup();
double fprime = slopeObj.computeSlope(searchDirection, oldGrp);
// Backtrack along tensor direction if it is descent direction.
if (fprime < 0)
{
ok = performLinesearch(newGrp, in_stepSize, searchDirection, s);
assert(ok);
fTensor = 0.5 * newGrp.getNormF() * newGrp.getNormF();
tensorStep = in_stepSize;
isTensorDescent = true;
}
// Backtrack along the Newton direction.
ok = performLinesearch(newGrp, in_stepSize, *newtonVecPtr, s);
fNew = 0.5 * newGrp.getNormF() * newGrp.getNormF();
// If backtracking on the tensor step produced a better step, then use it.
if (isTensorDescent && (fTensor <= fNew))
{
newGrp.computeX(oldGrp, *tensorVecPtr, tensorStep);
newGrp.computeF();
}
}
return ok;
}
NOX::StatusTest::StatusType NOX::StatusTest::NormF::
checkStatus(const NOX::Solver::Generic& problem,
NOX::StatusTest::CheckType checkType)
{
if (checkType == NOX::StatusTest::None)
{
normF = 0.0;
status = Unevaluated;
}
else
{
normF = computeNorm( problem.getSolutionGroup() );
status = ((normF != -1) && (normF < trueTolerance)) ? Converged : Unconverged;
}
return status;
}
bool NOX::LineSearch::Backtrack::
compute(NOX::Abstract::Group& grp, double& step,
const NOX::Abstract::Vector& dir,
const NOX::Solver::Generic& s)
{
const Abstract::Group& oldGrp = s.getPreviousSolutionGroup();
double oldF = meritFunctionPtr->computef(oldGrp);
double newF;
bool isFailed = false;
step = defaultStep;
grp.computeX(oldGrp, dir, step);
NOX::Abstract::Group::ReturnType rtype;
rtype = grp.computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utils->err() << "NOX::LineSearch::BackTrack::compute - Unable to compute F"
<< std::endl;
throw "NOX Error";
}
newF = meritFunctionPtr->computef(grp);
int nIters = 1;
if (utils->isPrintType(Utils::InnerIteration))
{
utils->out() << "\n" << Utils::fill(72) << "\n"
<< "-- Backtrack Line Search -- \n";
}
NOX::StatusTest::FiniteValue checkNAN;
while ( ((newF >= oldF) || (checkNAN.finiteNumberTest(newF) !=0))
&& (!isFailed))
{
if (utils->isPrintType(Utils::InnerIteration))
{
utils->out() << std::setw(3) << nIters << ":";
utils->out() << " step = " << utils->sciformat(step);
utils->out() << " old f = " << utils->sciformat(oldF);
utils->out() << " new f = " << utils->sciformat(newF);
utils->out() << std::endl;
}
nIters ++;
step = step * reductionFactor;
if ((step < minStep) || (nIters > maxIters))
{
isFailed = true;
step = recoveryStep;
}
grp.computeX(oldGrp, dir, step);
rtype = grp.computeF();
if (rtype != NOX::Abstract::Group::Ok)
{
utils->err() << "NOX::LineSearch::BackTrack::compute - Unable to compute F" << std::endl;
throw "NOX Error";
}
newF = meritFunctionPtr->computef(grp);
}
if (utils->isPrintType(Utils::InnerIteration))
{
utils->out() << std::setw(3) << nIters << ":";
utils->out() << " step = " << utils->sciformat(step);
utils->out() << " old f = " << utils->sciformat(oldF);
utils->out() << " new f = " << utils->sciformat(newF);
if (isFailed)
utils->out() << " (USING RECOVERY STEP!)" << std::endl;
else
utils->out() << " (STEP ACCEPTED!)" << std::endl;
utils->out() << Utils::fill(72) << "\n" << std::endl;
}
return (!isFailed);
}
StatusType NormWRMS::
checkStatus(const NOX::Solver::Generic& problem,
NOX::StatusTest::CheckType checkType)
{
if (checkType == NOX::StatusTest::None) {
status = Unevaluated;
value = 1.0e+12;
return status;
}
status = Unconverged;
const Abstract::Group& soln = problem.getSolutionGroup();
const Abstract::Group& oldsoln = problem.getPreviousSolutionGroup();
const Abstract::Vector& x = soln.getScaledX();
// On the first iteration, the old and current solution are the same so
// we should return the test as unconverged until there is a valid
// old solution (i.e. the number of iterations is greater than zero).
int niters = problem.getNumIterations();
if (niters == 0)
{
status = Unconverged;
value = 1.0e+12;
return status;
}
// **** Begin check for convergence criteria #1 ****
// Create the working vectors if this is the first time this
// operator is called.
if (Teuchos::is_null(u))
u = x.clone(NOX::ShapeCopy);
if (Teuchos::is_null(v))
v = x.clone(NOX::ShapeCopy);
// Create the weighting vector u = RTOL |x| + ATOL
// |x| is evaluated at the old time step
v->abs(oldsoln.getScaledX());
if (atolIsScalar)
{
u->init(1.0);
u->update(rtol, *v, atol);
}
else
{
u->update(rtol, *v, 1.0, *atolVec, 0.0);
}
// v = 1/u (elementwise)
v->reciprocal(*u);
// u = x - oldx (i.e., the update)
u->update(1.0, x, -1.0, oldsoln.getScaledX(), 0.0);
// u = Cp * u @ v (where @ represents an elementwise multiply)
u->scale(*v);
// Turn off implicit scaling of norm if the vector supports it
Teuchos::RCP<NOX::Abstract::ImplicitWeighting> iw_u;
iw_u = Teuchos::rcp_dynamic_cast<NOX::Abstract::ImplicitWeighting>(u,false);
bool saved_status = false;
if (nonnull(iw_u) && m_disable_implicit_weighting) {
saved_status = iw_u->getImplicitWeighting();
iw_u->setImplicitWeighting(false);
}
// tmp = factor * sqrt (u * u / N)
value = u->norm() * factor / sqrt(static_cast<double>(u->length()));
// Set the implicit scaling back to original value
if (nonnull(iw_u) && m_disable_implicit_weighting)
iw_u->setImplicitWeighting(saved_status);
StatusType status1 = Unconverged;
if (value < tolerance)
status1 = Converged;
// **** Begin check for convergence criteria #2 ****
StatusType status2 = Unconverged;
// Determine if the Generic solver is a LineSearchBased solver
// If it is not then return a "Converged" status
const Solver::Generic* test = 0;
test = dynamic_cast<const Solver::LineSearchBased*>(&problem);
if (test == 0)
{
status2 = Converged;
}
else
{
printCriteria2Info = true;
computedStepSize =
(dynamic_cast<const Solver::LineSearchBased*>(&problem))->getStepSize();
if (computedStepSize >= alpha)
status2 = Converged;
}
// **** Begin check for convergence criteria #3 ****
// First time through, make sure the output parameter list exists.
// Since the list is const, a sublist call to a non-existent sublist
// throws an error. Therefore we have to check the existence of each
// sublist before we call it.
const Teuchos::ParameterList& p = problem.getList();
if (niters == 1) {
if (p.isSublist("Direction")) {
if (p.sublist("Direction").isSublist("Newton")) {
if (p.sublist("Direction").sublist("Newton").isSublist("Linear Solver")) {
if (p.sublist("Direction").sublist("Newton").sublist("Linear Solver").isSublist("Output")) {
const Teuchos::ParameterList& list = p.sublist("Direction").sublist("Newton").sublist("Linear Solver").sublist("Output");
if (Teuchos::isParameterType<double>(list, "Achieved Tolerance")) {
printCriteria3Info = true;
}
}
}
}
}
}
StatusType status3 = Converged;
if (printCriteria3Info) {
achievedTol = const_cast<Teuchos::ParameterList&>(problem.getList()).
sublist("Direction").sublist("Newton").sublist("Linear Solver").
sublist("Output").get("Achieved Tolerance", -1.0);
status3 = (achievedTol <= beta) ? Converged : Unconverged;
}
// Determine status of test
if ((status1 == Converged) &&
(status2 == Converged) &&
(status3 == Converged))
status = Converged;
return status;
}
NOX::StatusTest::StatusType
LOCA::Bifurcation::TPBord::StatusTest::NullVectorNormWRMS::checkStatus(
const NOX::Solver::Generic& problem)
{
// Get solution groups from solver
const NOX::Abstract::Group& soln = problem.getSolutionGroup();
const NOX::Abstract::Group& oldsoln = problem.getPreviousSolutionGroup();
// Cast soln group to turning point group
const LOCA::Bifurcation::TPBord::ExtendedGroup* tpGroupPtr =
dynamic_cast<const LOCA::Bifurcation::TPBord::ExtendedGroup*>(&soln);
// Check that group is a turning point group, return converged if not
if (tpGroupPtr == NULL) {
normWRMS = 0.0;
return NOX::StatusTest::Converged;
}
// Get solution vectors
const LOCA::Bifurcation::TPBord::ExtendedVector& x =
dynamic_cast<const LOCA::Bifurcation::TPBord::ExtendedVector&>(soln.getX());
const LOCA::Bifurcation::TPBord::ExtendedVector& xold =
dynamic_cast<const LOCA::Bifurcation::TPBord::ExtendedVector&>(oldsoln.getX());
// Get null vectors
const NOX::Abstract::Vector& y = x.getNullVec();
const NOX::Abstract::Vector& yold = xold.getNullVec();
// temporary vectors
NOX::Abstract::Vector *u = y.clone(NOX::ShapeCopy);
NOX::Abstract::Vector *v = yold.clone(NOX::ShapeCopy);
// On the first iteration, the old and current solution are the same so
// we should return the test as unconverged until there is a valid
// old solution (i.e. the number of iterations is greater than zero).
int niters = problem.getNumIterations();
if (niters == 0)
{
normWRMS = 1.0e+12;
status = NOX::StatusTest::Unconverged;
return status;
}
// Fill vector with 1's
u->init(1.0);
// Compute |y|
v->abs(y);
// Overwrite u with rtol*|y| + atol
u->update(rtol, *v, atol);
// Overwrite v with 1/(rtol*|y| + atol)
v->reciprocal(*u);
// Overwrite u with y-yold
u->update(1.0, y, -1.0, yold, 0.0);
// Overwrite u with (y-yold)/(rtol*|y| + atol)
u->scale(*v);
// Compute sqrt( (y-yold)/(rtol*|y| + atol) ) / sqrt(N)
normWRMS = u->norm() / sqrt(static_cast<double>(u->length()));
if (normWRMS < tol)
status = NOX::StatusTest::Converged;
else
status = NOX::StatusTest::Unconverged;
delete u;
delete v;
return status;
}
bool
NOX::Solver::TensorBased::performLinesearch(NOX::Abstract::Group& newSoln,
double& in_stepSize,
const NOX::Abstract::Vector& lsDir,
const NOX::Solver::Generic& s)
{
if (print.isPrintType(NOX::Utils::InnerIteration))
{
utilsPtr->out() << "\n" << NOX::Utils::fill(72) << "\n";
utilsPtr->out() << "-- Tensor Line Search (";
if (lsType == Curvilinear)
utilsPtr->out() << "Curvilinear";
else if (lsType == Standard)
utilsPtr->out() << "Standard";
else if (lsType == FullStep)
utilsPtr->out() << "Full Step";
else if (lsType == Dual)
utilsPtr->out() << "Dual";
utilsPtr->out() << ") -- " << std::endl;
}
// Local variables
bool isFailed = false;
bool isAcceptable = false;
bool isFirstPass = true;
std::string message = "(STEP ACCEPTED!)";
// Set counters
int lsIterations = 1;
// Get Old f
const Abstract::Group& oldSoln = s.getPreviousSolutionGroup();
double fOld = 0.5 * oldSoln.getNormF() * oldSoln.getNormF();
// Compute first trial point and its function value
in_stepSize = defaultStep;
newSoln.computeX(oldSoln, lsDir, in_stepSize);
newSoln.computeF();
double fNew = 0.5 * newSoln.getNormF() * newSoln.getNormF();
// Stop here if only using the full step
if (lsType == FullStep)
{
print.printStep(lsIterations, in_stepSize, fOld, fNew, message);
return (!isFailed);
}
// Compute directional derivative
double fprime;
if ((lsType == Curvilinear) && !(isNewtonDirection))
fprime = slopeObj.computeSlope(*newtonVecPtr, oldSoln);
else
fprime = slopeObj.computeSlope(lsDir, oldSoln);
numJvMults++; // computeSlope() has J*v inside of it
// Compute the convergence criteria for the line search
double threshold = fOld + alpha*in_stepSize*fprime;
isAcceptable = (fNew < threshold);
// Update counter and temporarily hold direction if a linesearch is needed
if (!isAcceptable)
{
counter.incrementNumNonTrivialLineSearches();
*tmpVecPtr = lsDir;
}
// Iterate until the trial point is accepted....
while (!isAcceptable)
{
// Check for linesearch failure
if (lsIterations > maxIters)
{
isFailed = true;
message = "(FAILED - Max Iters)";
break;
}
print.printStep(lsIterations, in_stepSize, fOld, fNew);
// Is the full tensor step a descent direction? If not, switch to Newton
if (isFirstPass &&
(!isNewtonDirection) &&
(fprime >= 0) &&
(lsType != Curvilinear) )
{
*tmpVecPtr = *newtonVecPtr;
fprime = slopeObj.computeSlope(*tmpVecPtr, oldSoln);
numJvMults++;
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " Switching to Newton step. New fprime = "
<< utilsPtr->sciformat(fprime, 6) << std::endl;
}
else
{
in_stepSize = selectLambda(fNew, fOld, fprime, in_stepSize);
}
isFirstPass = false;
// Check for linesearch failure
if (in_stepSize < minStep)
{
isFailed = true;
message = "(FAILED - Min Step)";
break;
}
// Update the number of linesearch iterations
counter.incrementNumIterations();
lsIterations ++;
// Compute new trial point and its function value
if ((lsType == Curvilinear) && !(isNewtonDirection))
{
computeCurvilinearStep(*tmpVecPtr, oldSoln, s, in_stepSize);
// Note: oldSoln is needed above to get correct preconditioner
newSoln.computeX(oldSoln, *tmpVecPtr, 1.0);
}
else
{
newSoln.computeX(oldSoln, *tmpVecPtr, in_stepSize);
}
newSoln.computeF();
fNew = 0.5 * newSoln.getNormF() * newSoln.getNormF();
// Recompute convergence criteria based on new step
threshold = fOld + alpha*in_stepSize*fprime;
isAcceptable = (fNew < threshold);
}
if (isFailed)
{
counter.incrementNumFailedLineSearches();
if (recoveryStepType == Constant)
{
in_stepSize = recoveryStep;
if (in_stepSize == 0.0)
{
newSoln = oldSoln;
newSoln.computeF();
fNew = fOld;
}
else
{
// Update the group using recovery step
if ((lsType == Curvilinear) && !(isNewtonDirection))
{
computeCurvilinearStep(*tmpVecPtr, oldSoln, s, in_stepSize);
// Note: oldSoln is needed above to get correct preconditioner
newSoln.computeX(oldSoln, *tmpVecPtr, 1.0);
}
else
{
newSoln.computeX(oldSoln, *tmpVecPtr, in_stepSize);
}
//newSoln.computeX(oldSoln, lsDir, in_stepSize);
newSoln.computeF();
fNew = 0.5 * newSoln.getNormF() * newSoln.getNormF();
message = "(USING RECOVERY STEP!)";
}
}
else
message = "(USING LAST STEP!)";
}
print.printStep(lsIterations, in_stepSize, fOld, fNew, message);
counter.setValues(paramsPtr->sublist("Line Search"));
return (!isFailed);
}
bool
NOX::Solver::TensorBased::computeTensorDirection(NOX::Abstract::Group& soln,
const NOX::Solver::Generic& solver)
{
NOX::Abstract::Group::ReturnType dir_status;
Teuchos::ParameterList& linearParams = paramsPtr->sublist("Direction").
sublist(paramsPtr->sublist("Direction").
get("Method","Tensor")).
sublist("Linear Solver");
// Compute F at current solution.
dir_status = soln.computeF();
if (dir_status != NOX::Abstract::Group::Ok)
throwError("computeTensorDirection", "Unable to compute F");
// Compute Jacobian at current solution.
dir_status = soln.computeJacobian();
if (dir_status != NOX::Abstract::Group::Ok)
throwError("computeTensorDirection", "Unable to compute Jacobian");
// Begin processing for the tensor step, if necessary.
double sDotS = 0.0;
int tempVal1 = 0;
if ((nIter > 0) && (requestedBaseStep == TensorStep))
{
// Compute the tensor term s = x_{k-1} - x_k
*sVecPtr = soln.getX();
sVecPtr->update(1.0, solver.getPreviousSolutionGroup().getX(), -1.0);
double normS = sVecPtr->norm();
sDotS = normS * normS;
// Form the tensor term a = (F_{k-1} - F_k - J*s) / (s^T s)^2
soln.applyJacobian(*sVecPtr, *aVecPtr);
numJvMults++;
aVecPtr->update(1.0, solver.getPreviousSolutionGroup().getF(), -1.0);
aVecPtr->update(-1.0, soln.getF(), 1.0);
if (sDotS != 0)
aVecPtr->scale(1.0 / (sDotS * sDotS));
// Save old Newton step as initial guess to second system
*tmpVecPtr = *newtonVecPtr;
tmpVecPtr->scale(-1.0); // Rewrite to avoid this?
// Compute residual of linear system using initial guess...
soln.applyJacobian(*tmpVecPtr, *residualVecPtr);
numJvMults++;
residualVecPtr->update(1.0, solver.getPreviousSolutionGroup().getF(),-1.0);
double residualNorm = residualVecPtr->norm();
#if DEBUG_LEVEL > 0
double tmpVecNorm = tmpVecPtr->norm();
double residualNormRel = residualNorm /
solver.getPreviousSolutionGroup().getNormF();
if (utilsPtr->isPrintType(NOX::Utils::Details))
{
utilsPtr->out() << " Norm of initial guess: " << utilsPtr->sciformat(tmpVecNorm, 6)
<< std::endl;
utilsPtr->out() << " initg norm of model residual = "
<< utilsPtr->sciformat(residualNorm, 6) << " (abs) "
<< utilsPtr->sciformat(residualNormRel, 6) << " (rel)" << std::endl;
}
#endif
// Save some parameters and use them later...
double tol = linearParams.get("Tolerance", 1e-4);
double relativeResidual = residualNorm /
solver.getPreviousSolutionGroup().getNormF();
// Decide whether to use initial guess...
bool isInitialGuessGood = false;
#ifdef USE_INITIAL_GUESS_LOGIC
if (relativeResidual < 1.0)
{
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " Initial guess is good..." << std::endl;
isInitialGuessGood = true;
// RPP - Brett please make sure the line below is correct.
*tensorVecPtr = *tmpVecPtr;
double newTol = tol / relativeResidual;
if (newTol > 0.99)
newTol = 0.99; // force at least one iteration
linearParams.set("Tolerance", newTol);
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " Setting tolerance to " << utilsPtr->sciformat(newTol,6) << std::endl;
}
else
#endif // USE_INITIAL_GUESS_LOGIC
{
//utilsPtr->out() << " Initial guess is BAD... do not use!\n";
isInitialGuessGood = false;
*residualVecPtr = solver.getPreviousSolutionGroup().getF();
}
// Compute the term inv(J)*Fp....
tmpVecPtr->init(0.0);
dir_status = soln.applyJacobianInverse(linearParams, *residualVecPtr,
*tmpVecPtr);
// If it didn't converge, maybe we can recover.
if (dir_status != NOX::Abstract::Group::Ok)
{
if (doRescue == false)
throwError("computeTensorDirection", "Unable to apply Jacobian inverse");
else if ((doRescue == true) &&
(utilsPtr->isPrintType(NOX::Utils::Warning)))
utilsPtr->out() << "WARNING: NOX::Solver::TensorBased::computeTensorDirection() - "
<< "Linear solve failed to achieve convergence - "
<< "using the step anyway "
<< "since \"Rescue Bad Newton Solve\" is true." << std::endl;
}
// Continue processing
#ifdef USE_INITIAL_GUESS_LOGIC
if (isInitialGuessGood)
{
tmpVecPtr->update(1.0, *tensorVecPtr, 1.0);
linearParams.set("Tolerance", tol);
}
#endif
// Save iteration count for comparison later
if (linearParams.sublist("Output").
isParameter("Number of Linear Iterations"))
tempVal1 = linearParams.sublist("Output").
get("Number of Linear Iterations",0);
#if DEBUG_LEVEL > 0
// Compute residual of linear system with initial guess...
soln.applyJacobian(*tmpVecPtr, *residualVecPtr);
numJvMults++;
residualVec.update(-1.0, solver.getPreviousSolutionGroup().getF(),1.0);
double residualNorm2 = residualVec.norm();
double residualNorm2Rel = residualNorm2 /
solver.getPreviousSolutionGroup().getNormF();
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " jifp norm of model residual = "
<< utilsPtr->sciformat(residualNorm2, 6) << " (abs) "
<< utilsPtr->sciformat(residualNorm2Rel, 6) << " (rel)" << std::endl;
#endif
}
// Compute the Newton direction
dir_status = soln.computeNewton(linearParams);
// If it didn't converge, maybe we can recover.
if (dir_status != NOX::Abstract::Group::Ok)
{
if (doRescue == false)
throwError("computeTensorDirection", "Unable to apply Jacobian inverse");
else if ((doRescue == true) &&
(utilsPtr->isPrintType(NOX::Utils::Warning)))
utilsPtr->out() << "WARNING: NOX::Solver::TensorBased::computeTensorDirection() - "
<< "Linear solve failed to achieve convergence - "
<< "using the step anyway "
<< "since \"Rescue Bad Newton Solve\" is true." << std::endl;
}
// Set Newton direction
*newtonVecPtr = soln.getNewton();
// Update counter
int tempVal2 = 0;
if (linearParams.sublist("Output").
isParameter("Number of Linear Iterations"))
tempVal2 = linearParams.sublist("Output").
get("Number of Linear Iterations",0);
numJ2vMults += (tempVal1 > tempVal2) ? tempVal1 : tempVal2;
#ifdef CHECK_RESIDUALS
printDirectionInfo("newtonVec", *newtonVecPtr, soln, false);
#endif // CHECK_RESIDUALS
// Continue processing the tensor step, if necessary
if ((nIter > 0) && (requestedBaseStep == TensorStep))
{
// Form the term inv(J)*a... (note that a is not multiplied by 2)
// The next line does not work in some implementations for some reason
//tmpVec.update(1.0, newtonVec, -1.0, sVec, 1.0);
tmpVecPtr->update(1.0, *newtonVecPtr, 1.0);
tmpVecPtr->update(-1.0, *sVecPtr, 1.0);
if (sDotS != 0.0)
tmpVecPtr->scale( 1.0 / (sDotS * sDotS));
// Calculate value of beta
sTinvJF = -sVecPtr->innerProduct(*newtonVecPtr);
sTinvJa = sVecPtr->innerProduct(*tmpVecPtr);
double qval = 0;
double lambdaBar = 1;
beta = calculateBeta(sTinvJa, 1.0, sTinvJF, qval, lambdaBar);
double sVecNorm = sVecPtr->norm();
double aVecNorm = aVecPtr->norm();
if (utilsPtr->isPrintType(NOX::Utils::Details))
{
utilsPtr->out() << " sTinvJF = " << utilsPtr->sciformat(sTinvJF, 6)
<< " sTinvJa = " << utilsPtr->sciformat(sTinvJa, 6) << std::endl;
utilsPtr->out() << " norm(s) = " << utilsPtr->sciformat(sVecNorm, 6)
<< " norm(a) = " << utilsPtr->sciformat(aVecNorm, 6) << std::endl;
}
if (useModifiedMethod)
{
double alpha2 = lambdaBar;
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " Beta = " << utilsPtr->sciformat(beta, 6)
<< " Alpha2 = " << utilsPtr->sciformat(alpha2, 6) << std::endl;
if (alpha2 != 1.0)
{
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " *** Scaling tensor term a ***" << std::endl;
aVecPtr->scale(alpha2);
tmpVecPtr->scale(alpha2);
sTinvJa *= alpha2;
beta /= alpha2;
lambdaBar = 1.0;
qval = 0;
}
}
// Form the tensor step
tensorVecPtr->update(1.0, *newtonVecPtr, -beta*beta, *tmpVecPtr, 0.0);
#ifdef CHECK_RESIDUALS
printDirectionInfo("tensorVec", *tensorVecPtr, soln, true);
#endif // CHECK_RESIDUALS
#if DEBUG_LEVEL > 0
double sDotT = tensorVecPtr->innerProduct(sVec);
if (utilsPtr->isPrintType(NOX::Utils::Details))
utilsPtr->out() << " Beta = " << utilsPtr->sciformat(beta, 6)
<< " std = " << utilsPtr->sciformat(sDotT, 6)
<< " qval = " << utilsPtr->sciformat(qval, 2)
<< " lambdaBar = " << lambdaBar << std::endl;
#endif
}
else
*tensorVecPtr = *newtonVecPtr;
return true;
}
