NOX::Abstract::Group::ReturnType
LOCA::LAPACK::Group::applyJacobianTransposeInverse(
Teuchos::ParameterList& p,
const NOX::Abstract::Vector& input,
NOX::Abstract::Vector& result) const
{
if (!isJacobian()) {
cerr << "ERROR: "
<< "LOCA::LAPACK::Group::applyJacobianTransposeInverse()"
<< " - invalid Jacobian" << endl;
throw "NOX Error";
}
const NOX::LAPACK::Vector& lapack_input =
dynamic_cast<const NOX::LAPACK::Vector&> (input);
NOX::LAPACK::Vector& lapack_result =
dynamic_cast<NOX::LAPACK::Vector&> (result);
// Solve Jacobian transpose
lapack_result = lapack_input;
bool res = jacSolver.solve(true, 1, &lapack_result(0));
return res ? (NOX::Abstract::Group::Ok) : (NOX::Abstract::Group::Failed);
}
NOX::Abstract::Group::ReturnType
NOX::Belos::Group::computeNewton(NOX::Parameter::List& params)
{
if (isValidNewton)
return NOX::Abstract::Group::Ok;
if (!isF()) {
std::cerr << "ERROR: NOX::Belos::Group::computeNewton() - invalid RHS" << std::endl;
throw "NOX Error";
}
if (!isJacobian()) {
std::cerr << "ERROR: NOX::Belos::Group::computeNewton() - invalid Jacobian"
<< std::endl;
throw "NOX Error";
}
Abstract::Group::ReturnType status;
// zero out newton vec -- used as initial guess for some linear solvers
newtonVecPtr->init(0.0);
status = applyJacobianInverse(params, getF(), *newtonVecPtr);
newtonVecPtr->scale(-1.0);
// Update state EVEN IF LINEAR SOLVE FAILED
// We still may want to use the vector even it it just missed it's
isValidNewton = true;
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::Epetra::Group::computeJacobian()
{
if (isJacobian())
return Abstract::Group::Ok;
// Set the parameters prior to computing F
userInterface->setParameters(params);
return NOX::Epetra::Group::computeJacobian();
}
NOX::Abstract::Group::ReturnType
NOX::LAPACK::Group::applyJacobianTranspose(const Vector& input, Vector& result) const
{
// Check validity of the Jacobian
if (!isJacobian())
return NOX::Abstract::Group::BadDependency;
// Apply Jacobian transpose
jacSolver.apply(true, 1, &input(0), &result(0));
return NOX::Abstract::Group::Ok;
}
NOX::Abstract::Group::ReturnType
LOCA::Homotopy::DeflatedGroup::
applyJacobianTransposeMultiVector(const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::applyJacobianTransposeMultiVector()";
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast inputs to continuation multivectors
const LOCA::MultiContinuation::ExtendedMultiVector& c_input =
dynamic_cast<const LOCA::MultiContinuation::ExtendedMultiVector&>(input);
LOCA::MultiContinuation::ExtendedMultiVector& c_result =
dynamic_cast<LOCA::MultiContinuation::ExtendedMultiVector&>(result);
// Get x, param componenets of input vector
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
c_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param = c_input.getScalars();
// Get references to x, param components of result vector
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
c_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
c_result.getScalars();
NOX::Abstract::Group::ReturnType status =
grpPtr->applyJacobianTransposeMultiVector(*input_x, *result_x);
// If the Jacobian is not augmented for homotopy (i.e. using MFNK)
// then lets augment it here.
if (augmentJacForHomotopyNotImplemented)
result_x->update(1.0-conParam, *input_x, conParam/distProd);
// Add deflated terms
if (numSolns > 0) {
NOX::Abstract::MultiVector::DenseMatrix tmp(1, input.numVectors());
input_x->multiply(1.0, *underlyingF, tmp);
result_x->update(Teuchos::NO_TRANS, 1.0, *totalDistMultiVec, tmp, 1.0);
}
// Zero out parameter component
result_param->putScalar(0.0);
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::ConstrainedGroup::applyJacobianTransposeInverseMultiVector(
Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
std::string callingFunction =
"LOCA::MultiContinuation::ConstrainedGroup::applyJacobianTransposeInverseMultiVector()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast inputs to continuation multivectors
const LOCA::MultiContinuation::ExtendedMultiVector& c_input =
dynamic_cast<const LOCA::MultiContinuation::ExtendedMultiVector&>(input);
LOCA::MultiContinuation::ExtendedMultiVector& c_result =
dynamic_cast<LOCA::MultiContinuation::ExtendedMultiVector&>(result);
// Get x, param componenets of input vector
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
c_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param = c_input.getScalars();
// Get references to x, param components of result vector
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
c_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
c_result.getScalars();
// Call bordered solver applyInverseTranspose method
status =
borderedSolver->initForTransposeSolve();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
status = borderedSolver->applyInverseTranspose(params, input_x.get(),
input_param.get(),
*result_x, *result_param);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::Homotopy::DeflatedGroup::
applyJacobianInverseMultiVector(Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::applyJacobianInverseMultiVector()";
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast inputs to continuation multivectors
const LOCA::MultiContinuation::ExtendedMultiVector& c_input =
dynamic_cast<const LOCA::MultiContinuation::ExtendedMultiVector&>(input);
LOCA::MultiContinuation::ExtendedMultiVector& c_result =
dynamic_cast<LOCA::MultiContinuation::ExtendedMultiVector&>(result);
// Get x, param componenets of input vector
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
c_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param = c_input.getScalars();
// Get references to x, param components of result vector
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
c_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
c_result.getScalars();
NOX::Abstract::Group::ReturnType status;
if (numSolns > 0) {
// Call bordered solver applyInverse method
status =
borderedSolver->applyInverse(params, input_x.get(), input_param.get(),
*result_x, *result_param);
}
else {
status =
grpPtr->applyJacobianInverseMultiVector(params, *input_x, *result_x);
result_param->putScalar(0.0);
}
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::Homotopy::DeflatedGroup::
computeNewton(Teuchos::ParameterList& params)
{
if (isValidNewton)
return NOX::Abstract::Group::Ok;
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::computeNewton()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
// Make sure F is valid
if (!isF()) {
status = computeF();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Make sure Jacobian is valid
if (!isJacobian()) {
status = computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// zero out newton vec -- used as initial guess for some linear solvers
newtonMultiVec.init(0.0);
status = applyJacobianInverseMultiVector(params, fMultiVec,
newtonMultiVec);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
newtonMultiVec.scale(-1.0);
isValidNewton = true;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
NOX::LAPACK::Group::applyJacobianInverse(Teuchos::ParameterList& p,
const Vector& input,
Vector& result) const
{
if (!isJacobian()) {
std::cerr << "ERROR: NOX::LAPACK::Group::applyJacobianInverse() - invalid Jacobian" << std::endl;
throw "NOX Error";
}
// Solve Jacobian
result = input;
bool res = jacSolver.solve(false, 1, &result(0));
return res ? (NOX::Abstract::Group::Ok) : (NOX::Abstract::Group::Failed);
}
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MooreSpence::ExtendedGroup::computeNewton(
Teuchos::ParameterList& params)
{
if (isValidNewton)
return NOX::Abstract::Group::Ok;
string callingFunction =
"LOCA::TurningPoint::MooreSpence::ExtendedGroup::computeNewton()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
// Make sure F is valid
if (!isF()) {
status = computeF();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Make sure Jacobian is valid
if (!isJacobian()) {
status = computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// zero out newton vec -- used as initial guess for some linear solvers
newtonMultiVec.init(0.0);
// solve using contiguous
status = solverStrategy->solve(params, *ffMultiVec, newtonMultiVec);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
newtonMultiVec.scale(-1.0);
isValidNewton = true;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::LAPACK::Group::applyJacobianTransposeInverseMultiVector(
Teuchos::ParameterList& p,
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
if (!isJacobian()) {
cerr << "ERROR: "
<< "LOCA::LAPACK::Group::applyJacobianTransposeInverseMultiVector()"
<< " - invalid Jacobian" << endl;
throw "NOX Error";
}
// Number of RHS
int nVecs = input.numVectors();
int m = jacSolver.getMatrix().numRows();
// Copy all input vectors into one matrix
NOX::LAPACK::Matrix<double> B(m,nVecs);
const NOX::LAPACK::Vector* constVecPtr;
for (int j=0; j<nVecs; j++) {
constVecPtr = dynamic_cast<const NOX::LAPACK::Vector*>(&(input[j]));
for (int i=0; i<m; i++)
B(i,j) = (*constVecPtr)(i);
}
// Solve Jacobian transpose
bool res = jacSolver.solve(true, nVecs, &B(0,0));
if (!res)
return NOX::Abstract::Group::Failed;
// Copy result from matrix
NOX::LAPACK::Vector* vecPtr;
for (int j=0; j<nVecs; j++) {
vecPtr = dynamic_cast<NOX::LAPACK::Vector*>(&(result[j]));
for (int i=0; i<m; i++)
(*vecPtr)(i) = B(i,j);
}
return NOX::Abstract::Group::Ok;
}
NOX::Abstract::Group::ReturnType
LOCA::Homotopy::DeflatedGroup::
computeGradient()
{
if (isValidGradient)
return NOX::Abstract::Group::Ok;
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::computeGradient()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
// Make sure F is valid
if (!isF()) {
status = computeF();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Make sure Jacobian is valid
if (!isJacobian()) {
status = computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute J^T*f for homotopy group
status = applyJacobianTranspose(*fVec, *gradientVec);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
isValidGradient = true;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::ConstrainedGroup::applyJacobianTransposeMultiVector(
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
std::string callingFunction =
"LOCA::MultiContinuation::ConstrainedGroup::applyJacobianTransposeMultiVector()";
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast inputs to continuation multivectors
const LOCA::MultiContinuation::ExtendedMultiVector& c_input =
dynamic_cast<const LOCA::MultiContinuation::ExtendedMultiVector&>(input);
LOCA::MultiContinuation::ExtendedMultiVector& c_result =
dynamic_cast<LOCA::MultiContinuation::ExtendedMultiVector&>(result);
// Get x, param componenets of input vector
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
c_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param = c_input.getScalars();
// Get references to x, param components of result vector
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
c_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
c_result.getScalars();
// Call bordered solver applyTranspose method
NOX::Abstract::Group::ReturnType status =
borderedSolver->applyTranspose(*input_x, *input_param, *result_x,
*result_param);
return status;
}
NOX::Abstract::Group::ReturnType NOX::LAPACK::Group::computeNewton(Teuchos::ParameterList& p)
{
if (isNewton())
return NOX::Abstract::Group::Ok;
if (!isF()) {
std::cerr << "ERROR: NOX::Example::Group::computeNewton() - invalid F" << std::endl;
throw "NOX Error";
}
if (!isJacobian()) {
std::cerr << "ERROR: NOX::Example::Group::computeNewton() - invalid Jacobian" << std::endl;
throw "NOX Error";
}
NOX::Abstract::Group::ReturnType status = applyJacobianInverse(p, fVector, newtonVector);
isValidNewton = (status == NOX::Abstract::Group::Ok);
// Scale soln by -1
newtonVector.scale(-1.0);
// Return solution
return status;
}
NOX::Abstract::Group::ReturnType NOX::LAPACK::Group::computeGradient()
{
if (isValidGradient)
return NOX::Abstract::Group::Ok;
if (!isF()) {
std::cerr << "ERROR: NOX::LAPACK::Group::computeGrad() - F is out of date wrt X!" << std::endl;
return NOX::Abstract::Group::BadDependency;
}
if (!isJacobian()) {
std::cerr << "ERROR: NOX::LAPACK::Group::computeGrad() - Jacobian is out of date wrt X!" << std::endl;
return NOX::Abstract::Group::BadDependency;
}
// Compute Gradient = J' * F
jacSolver.apply(true, 1, &fVector(0), &gradientVector(0));
// Reset isValidGradient
isValidGradient = true;
// Return result
return NOX::Abstract::Group::Ok;
}
NOX::Abstract::Group::ReturnType LOCA::PhaseTransition::ExtendedGroup::computeNewton(Teuchos::ParameterList& p)
{
if (isNewton())
return NOX::Abstract::Group::Ok;
if (!isF()) {
cerr << "ERROR: NOX::Example::Group::computeNewton() - invalid F" << endl;
throw "NOX Error";
}
if (!isJacobian()) {
cerr << "ERROR: NOX::Example::Group::computeNewton() - invalid Jacobian" << endl;
throw "NOX Error";
}
NOX::Abstract::Group::ReturnType status = applyJacobianInverse(p, *fVector, *newtonVector);
isValidNewton = (status == NOX::Abstract::Group::Ok);
// Scale soln by -1
newtonVector->scale(-1.0);
// Return solution
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::ConstrainedGroup::computeGradient()
{
if (isValidGradient)
return NOX::Abstract::Group::Ok;
std::string callingFunction =
"LOCA::MultiContinuation::ConstrainedGroup::computeGradient()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
// Make sure F is valid
if (!isF()) {
status = computeF();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Make sure Jacobian is valid
if (!isJacobian()) {
status = computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute underlying gradient
if (!grpPtr->isGradient()) {
status = grpPtr->computeGradient();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Get grad f
*gradientVec->getXVec() = grpPtr->getGradient();
// compute grad f + dg/dx^T * g
constraintsPtr->addDX(Teuchos::TRANS, 1.0,
constraintsPtr->getConstraints(),
1.0,
*gradientMultiVec.getXMultiVec());
// compute df/dp^T * f
ffMultiVec->getXMultiVec()->multiply(1.0, *dfdpMultiVec->getXMultiVec(),
*gradientMultiVec.getScalars());
// compute df/dp^T * f + dg/dp^T * g
gradientMultiVec.getScalars()->multiply(
Teuchos::TRANS, Teuchos::NO_TRANS, 1.0,
*dfdpMultiVec->getScalars(),
constraintsPtr->getConstraints(), 1.0);
isValidGradient = true;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MooreSpence::ExtendedGroup::applyJacobianTransposeMultiVector(
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
string callingFunction =
"LOCA::TurningPoint::MooreSpence::ExtendedGroup::applyJacobianTransposeMultiVector()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast vectors to TP vectors
const LOCA::TurningPoint::MooreSpence::ExtendedMultiVector& tp_input =
dynamic_cast<const LOCA::TurningPoint::MooreSpence::ExtendedMultiVector&>(input);
LOCA::TurningPoint::MooreSpence::ExtendedMultiVector& tp_result =
dynamic_cast<LOCA::TurningPoint::MooreSpence::ExtendedMultiVector&>(result);
// Get constant references to input vector components
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
tp_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector> input_null =
tp_input.getNullMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param =
tp_input.getScalars();
// Get non-constant references to result vector components
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
tp_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector> result_null =
tp_result.getNullMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
tp_result.getScalars();
// Temporary vector
Teuchos::RCP<NOX::Abstract::MultiVector> tmp =
input_null->clone(NOX::ShapeCopy);
// verify underlying Jacobian is valid
if (!grpPtr->isJacobian()) {
status = grpPtr->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// compute J^T*x
status = grpPtr->applyJacobianTransposeMultiVector(*input_x, *result_x);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// compute J^T*y
status = grpPtr->applyJacobianTransposeMultiVector(*input_null, *result_null);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute (dJn/dx)^T*y
status = grpPtr->computeDwtJnDxMulti(*input_null, *(xVec->getNullVec()),
*tmp);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute J^T*x + (dJn/dx)^T*y
result_x->update(1.0, *tmp, 1.0);
// compute J^T*y + phi*z
result_null->update(Teuchos::NO_TRANS, 1.0/lengthVec->length(), *lengthMultiVec, *input_param, 1.0);
// compute (df/dp)^T*x
input_x->multiply(1.0, *(dfdpMultiVec->getXMultiVec()), *result_param);
// compute (dJn/dp)^T*y
NOX::Abstract::MultiVector::DenseMatrix t(1, input_param->numCols());
input_null->multiply(1.0, *(dfdpMultiVec->getNullMultiVec()), t);
// compute (df/dp)^T*x + (dJn/dp)^T*y
*result_param += t;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::Pitchfork::MooreSpence::ExtendedGroup::applyJacobianMultiVector(
const NOX::Abstract::MultiVector& input,
NOX::Abstract::MultiVector& result) const
{
string callingFunction =
"LOCA::Pitchfork::MooreSpence::ExtendedGroup::applyJacobianMultiVector()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
if (!isJacobian()) {
globalData->locaErrorCheck->throwError(callingFunction,
"Called with invalid Jacobian!");
}
// Cast vectors to pitchfork vectors
const LOCA::Pitchfork::MooreSpence::ExtendedMultiVector& pf_input =
dynamic_cast<const LOCA::Pitchfork::MooreSpence::ExtendedMultiVector&>(input);
LOCA::Pitchfork::MooreSpence::ExtendedMultiVector& pf_result =
dynamic_cast<LOCA::Pitchfork::MooreSpence::ExtendedMultiVector&>(result);
// Get constant references to input vector components
Teuchos::RCP<const NOX::Abstract::MultiVector> input_x =
pf_input.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector> input_null =
pf_input.getNullMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_slack = pf_input.getSlacks();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> input_param = pf_input.getBifParams();
// Get non-constant references to result vector components
Teuchos::RCP<NOX::Abstract::MultiVector> result_x =
pf_result.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector> result_null =
pf_result.getNullMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_slack =
pf_result.getSlacks();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_param =
pf_result.getBifParams();
// Temporary vector
Teuchos::RCP<NOX::Abstract::MultiVector> tmp =
input_null->clone(NOX::ShapeCopy);
// verify underlying Jacobian is valid
if (!grpPtr->isJacobian()) {
status = grpPtr->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// compute J*x
status = grpPtr->applyJacobianMultiVector(*input_x, *result_x);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// compute J*x + psi*sigma
result_x->update(Teuchos::NO_TRANS, 1.0, *asymMultiVec, *input_slack);
// compute J*x + psi*sigma + (dR/dp)*p
result_x->update(Teuchos::NO_TRANS, 1.0, *(dfdpMultiVec->getXMultiVec()),
*input_param);
// compute J*y
status = grpPtr->applyJacobianMultiVector(*input_null, *result_null);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute J*y + (dJy/dp)*p
result_null->update(Teuchos::NO_TRANS, 1.0,
*(dfdpMultiVec->getNullMultiVec()),
*input_param);
// compute (dJy/dx)*x
status = grpPtr->computeDJnDxaMulti(*(xVec->getNullVec()),
*(fVec->getNullVec()),
*input_x, *tmp);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute (dJy/dx)*x + J*y + p*dJy/dp
result_null->update(1.0, *tmp, 1.0);
// compute <x,psi>
grpPtr->innerProduct(*asymMultiVec, *input_x, *result_slack);
// compute l^T*y
lTransNorm(*input_null, *result_param);
return finalStatus;
}
