double NOX::StatusTest::NormF::computeNorm(const NOX::Abstract::Group& grp) { if (!grp.isF()) return -1.0; double norm; int n = grp.getX().length(); switch (normType) { case NOX::Abstract::Vector::TwoNorm: norm = grp.getNormF(); if (scaleType == Scaled) norm /= sqrt(1.0 * n); break; default: norm = grp.getF().norm(normType); if (scaleType == Scaled) norm /= n; break; } return norm; }
bool NOX::Direction::QuasiNewton::compute(NOX::Abstract::Vector& dir, NOX::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"); // Compute the gradient at the current solution status = soln.computeGradient(); if (status != NOX::Abstract::Group::Ok) throwError("compute", "Unable to compute gradient"); // Push the old information onto the memory, but only after at least one previous iteration if (solver.getNumIterations() > 0) { const NOX::Abstract::Group& oldSoln = solver.getPreviousSolutionGroup(); if (oldSoln.isGradient()) memory.add(soln.getX(), oldSoln.getX(), soln.getGradient(), oldSoln.getGradient()); } // *** Calculate the QN direction *** // d = -g dir = soln.getGradient(); dir.scale(-1.0); if (!memory.empty()) { int m = memory.size(); vector<double> alpha(m); double beta; for (int i = m-1; i >= 0; i --) { alpha[i] = memory[i].rho() * dir.innerProduct( memory[i].s() ); dir.update(-1.0 * alpha[i], memory[i].y(), 1.0); } dir.scale( memory[m-1].sdoty() / memory[m-1].ydoty() ); for (int i = 0; i < m; i ++) { beta = memory[i].rho() * dir.innerProduct( memory[i].y() ); dir.update(alpha[i] - beta, memory[i].s(), 1.0); } } return true; }
double NOX::MeritFunction::SumOfSquares:: computeSlopeWithoutJacobian(const NOX::Abstract::Vector& dir, const NOX::Abstract::Group& grp) const { if (Teuchos::is_null(tmpVecPtr)) tmpVecPtr = grp.getF().clone(NOX::ShapeCopy); if (Teuchos::is_null(tmpGrpPtr)) tmpGrpPtr = grp.clone(NOX::ShapeCopy); // 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 tmpVecPtr->update(eta, dir, 1.0, grp.getX(), 0.0); // Compute the new F --> F(x + eta * dir) tmpGrpPtr->setX(*(tmpVecPtr.get())); tmpGrpPtr->computeF(); // Compute Js = (F(x + eta * dir) - F(x))/eta tmpVecPtr->update(-1.0/eta, grp.getF(), 1.0/eta, tmpGrpPtr->getF(), 0.0); return(tmpVecPtr->innerProduct(grp.getF())); }
// ************************************************************************** // *** 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::Eigensolver::DGGEVStrategy::computeEigenvalues( NOX::Abstract::Group& group, Teuchos::RCP< std::vector<double> >& evals_r, Teuchos::RCP< std::vector<double> >& evals_i, Teuchos::RCP< NOX::Abstract::MultiVector >& evecs_r, Teuchos::RCP< NOX::Abstract::MultiVector >& evecs_i) { // Get LAPACK group LOCA::LAPACK::Group* grp = dynamic_cast<LOCA::LAPACK::Group*>(&group); bool hasMassMatrix = true; if (globalData->locaUtils->isPrintType(NOX::Utils::StepperIteration)) { globalData->locaUtils->out() << std::endl << globalData->locaUtils->fill(64,'=') << std::endl << "LAPACK "; if (hasMassMatrix) globalData->locaUtils->out() << "DGGEV "; else globalData->locaUtils->out() << "DGEEV "; globalData->locaUtils->out() << "Eigensolver starting." << std::endl << std::endl;; } // Make sure Jacobian & mass matrices are fresh grp->computeJacobian(); if (hasMassMatrix) grp->computeShiftedMatrix(0.0, 1.0); // Get data out of group NOX::LAPACK::Matrix<double>& jacobianMatrix = grp->getJacobianMatrix(); NOX::LAPACK::Matrix<double>& massMatrix = grp->getShiftedMatrix(); // Size of matrix int n = jacobianMatrix.numRows(); int lda = jacobianMatrix.numRows(); int ldb = massMatrix.numRows(); // Space to hold right eigenvectors double *vr = new double[n*n]; // Space to hold real and imaginary eigenvalues double *alphar = new double[n]; double *alphai = new double[n]; double *beta = new double[n]; // Size of work array, set to -1 to do a workspace query int lwork = -1; // Initial work "array" double work0; // Actual work array double *work; // Return code int info; // Copy Jacobian matrix since lapack routines overwrite it NOX::LAPACK::Matrix<double> J(jacobianMatrix); NOX::LAPACK::Matrix<double> M; // First do a workspace query if (hasMassMatrix) { // Copy mass matrix since lapack routines overwrite it M = massMatrix; DGGEV_F77("N", "V", &n, &J(0,0), &lda, &M(0,0), &ldb, alphar, alphai, beta, vr, &n, vr, &n, &work0, &lwork, &info); } else { DGEEV_F77("N", "V", &n, &J(0,0), &lda, alphar, alphai, vr, &n, vr, &n, &work0, &lwork, &info); } // Allocate work array lwork = (int) work0; work = new double[lwork]; // Calculate eigenvalues, eigenvectors if (hasMassMatrix) { DGGEV_F77("N", "V", &n, &J(0,0), &lda, &M(0,0), &ldb, alphar, alphai, beta, vr, &n, vr, &n, work, &lwork, &info); } else { DGEEV_F77("N", "V", &n, &J(0,0), &lda, alphar, alphai, vr, &n, vr, &n, work, &lwork, &info); } // Check for success if (info != 0) return NOX::Abstract::Group::Failed; // Compute all of the eigenvalues and eigenvectors before sorting std::vector<double> evals_r_tmp(n); std::vector<double> evals_i_tmp(n); Teuchos::RCP<NOX::Abstract::MultiVector> evecs_r_tmp = group.getX().createMultiVector(n, NOX::ShapeCopy); Teuchos::RCP<NOX::Abstract::MultiVector>evecs_i_tmp = group.getX().createMultiVector(n, NOX::ShapeCopy); NOX::LAPACK::Vector* tmpr; NOX::LAPACK::Vector* tmpi; double rnext; double inext; bool isComplexEval = false; bool isPrevComplexEval = false; for (int j=0; j<n; j++) { // Compute eigenvalues if (hasMassMatrix) { evals_r_tmp[j] = alphar[j]/beta[j]; evals_i_tmp[j] = alphai[j]/beta[j]; } else { evals_r_tmp[j] = alphar[j]; evals_i_tmp[j] = alphai[j]; } // Compute next eigenvalue if (!isPrevComplexEval && j < n-1) { if (hasMassMatrix) { rnext = alphar[j+1]/beta[j+1]; inext = alphai[j+1]/beta[j+1]; } else { rnext = alphar[j+1]; inext = alphai[j+1]; } // Determine if this eigenvalue is a complex conjugate pair if (fabs(evals_r_tmp[j] - rnext) < 1.0e-14*fabs(1.0+evals_r_tmp[j]) && fabs(evals_i_tmp[j] + inext) < 1.0e-14*fabs(1.0+evals_i_tmp[j])) isComplexEval = true; else isComplexEval = false; } else if (!isPrevComplexEval && j == n-1) isComplexEval = false; tmpr = dynamic_cast<NOX::LAPACK::Vector*>(&((*evecs_r_tmp)[j])); tmpi = dynamic_cast<NOX::LAPACK::Vector*>(&((*evecs_i_tmp)[j])); if (isComplexEval) for (int i=0; i<n; i++) { (*tmpr)(i) = vr[i+j*n]; (*tmpi)(i) = vr[i+(j+1)*n]; } else if (isPrevComplexEval) for (int i=0; i<n; i++) { (*tmpr)(i) = vr[i+(j-1)*n]; (*tmpi)(i) = -vr[i+j*n]; } else for (int i=0; i<n; i++) { (*tmpr)(i) = vr[i+j*n]; (*tmpi)(i) = 0.0;; } if (isPrevComplexEval) { isPrevComplexEval = false; isComplexEval = false; } if (isComplexEval) { isPrevComplexEval = true; isComplexEval = false; } } // Instantiate a sorting strategy Teuchos::RCP<LOCA::EigenvalueSort::AbstractStrategy> evalSort = globalData->locaFactory->createEigenvalueSortStrategy(topParams, eigenParams); // Create permutation array std::vector<int> perm(n); // Sort eigenvalues evalSort->sort(n, &evals_r_tmp[0], &evals_i_tmp[0], &perm); // Get first nev entries of perm std::vector<int> perm_short(perm.begin(), perm.begin()+nev); // Get sorted eigenvalues and eigenvectors evals_r = Teuchos::rcp(new std::vector<double>(evals_r_tmp.begin(), evals_r_tmp.begin()+nev)); evals_i = Teuchos::rcp(new std::vector<double>(evals_i_tmp.begin(), evals_i_tmp.begin()+nev)); evecs_r = evecs_r_tmp->subCopy(perm_short); evecs_i = evecs_i_tmp->subCopy(perm_short); // Print out eigenvalues if (globalData->locaUtils->isPrintType(NOX::Utils::StepperIteration)) { for (int i=0; i<nev; i++) globalData->locaUtils->out() << "Eigenvalue " << i << " : " << globalData->locaUtils->sciformat((*evals_r)[i]) << " " << globalData->locaUtils->sciformat((*evals_i)[i]) << " i" << std::endl; } if (globalData->locaUtils->isPrintType(NOX::Utils::StepperIteration)) globalData->locaUtils->out() << "\nLAPACK Eigensolver finished.\n" << globalData->locaUtils->fill(64,'=') << "\n" << std::endl; delete [] alphar; delete [] alphai; delete [] beta; delete [] vr; delete [] work; return NOX::Abstract::Group::Ok; }
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; }