void
LOCA::MultiContinuation::ConstrainedGroup::fillB(
NOX::Abstract::MultiVector& B) const
{
std::string callingFunction =
"LOCA::MultiContinuation::ConstrainedGroup::fillB";
bool isZeroB = constraintsPtr->isDXZero();
Teuchos::RCP<const NOX::Abstract::MultiVector> my_B;
if (!isZeroB) {
Teuchos::RCP<const LOCA::MultiContinuation::ConstraintInterfaceMVDX> constraints_mvdx = Teuchos::rcp_dynamic_cast<const LOCA::MultiContinuation::ConstraintInterfaceMVDX>(constraintsPtr);
if (constraints_mvdx == Teuchos::null)
globalData->locaErrorCheck->throwError(
callingFunction,
std::string("Constraints object must be of type") +
std::string("ConstraintInterfaceMVDX"));
my_B = Teuchos::rcp(constraints_mvdx->getDX(),false);
}
// If the underlying system isn't bordered, we're done
if (!isBordered) {
if (isZeroB)
B.init(0.0);
else
B = *my_B;
return;
}
// Create views for underlying group
int w = bordered_grp->getBorderedWidth();
std::vector<int> idx1(w);
for (int i=0; i<w; i++)
idx1[i] = i;
Teuchos::RCP<NOX::Abstract::MultiVector> underlyingB =
B.subView(idx1);
// Combine blocks in underlying group
bordered_grp->fillB(*underlyingB);
// Create views for my blocks
std::vector<int> idx2(numParams);
for (int i=0; i<numParams; i++)
idx2[i] = w+i;
Teuchos::RCP<NOX::Abstract::MultiVector> my_B_x =
B.subView(idx2);
// Extract solution component from my_B and store in B
if (isZeroB)
my_B_x->init(0.0);
else
bordered_grp->extractSolutionComponent(*my_B, *my_B_x);
}
NOX::Abstract::Group::ReturnType
LOCA::Epetra::ModelEvaluatorInterface::
computeDfDp(LOCA::MultiContinuation::AbstractGroup& grp,
const vector<int>& param_ids,
NOX::Abstract::MultiVector& result,
bool isValidF) const
{
// Break result into f and df/dp
NOX::Epetra::Vector& f = dynamic_cast<NOX::Epetra::Vector&>(result[0]);
Epetra_Vector& epetra_f = f.getEpetraVector();
std::vector<int> dfdp_index(result.numVectors()-1);
for (unsigned int i=0; i<dfdp_index.size(); i++)
dfdp_index[i] = i+1;
Teuchos::RefCountPtr<NOX::Epetra::MultiVector> dfdp =
Teuchos::rcp_dynamic_cast<NOX::Epetra::MultiVector>(result.subView(dfdp_index));
Epetra_MultiVector& epetra_dfdp = dfdp->getEpetraMultiVector();
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
const NOX::Epetra::Vector& x =
dynamic_cast<const NOX::Epetra::Vector&>(grp.getX());
const Epetra_Vector& epetra_x = x.getEpetraVector();
inargs.set_x(Teuchos::rcp(&epetra_x, false));
inargs.set_p(0, Teuchos::rcp(¶m_vec, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_x_dot)) {
// Create x_dot, filled with zeros
if (x_dot == NULL)
x_dot = new Epetra_Vector(epetra_x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
if (!isValidF) {
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
Teuchos::RefCountPtr<Epetra_Vector> F = Teuchos::rcp(&epetra_f, false);
eval_f.reset(F, EpetraExt::ModelEvaluator::EVAL_TYPE_EXACT);
outargs.set_f(eval_f);
}
Teuchos::RefCountPtr<Epetra_MultiVector> DfDp =
Teuchos::rcp(&epetra_dfdp, false);
Teuchos::Array<int> param_indexes(param_ids.size());
for (unsigned int i=0; i<param_ids.size(); i++)
param_indexes[i] = param_ids[i];
EpetraExt::ModelEvaluator::DerivativeMultiVector dmv(DfDp, EpetraExt::ModelEvaluator::DERIV_MV_BY_COL,
param_indexes);
EpetraExt::ModelEvaluator::Derivative deriv(dmv);
outargs.set_DfDp(0, deriv);
model_->evalModel(inargs, outargs);
return NOX::Abstract::Group::Ok;
}
void
LOCA::Homotopy::DeflatedGroup::
fillB(NOX::Abstract::MultiVector& B) const
{
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::fillB";
Teuchos::RCP<const NOX::Abstract::MultiVector> my_B =
totalDistMultiVec;
// If the underlying system isn't bordered, we're done
if (!isBordered) {
B = *my_B;
return;
}
// Create views for underlying group
int w = bordered_grp->getBorderedWidth();
std::vector<int> idx1(w);
for (int i=0; i<w; i++)
idx1[i] = i;
Teuchos::RCP<NOX::Abstract::MultiVector> underlyingB =
B.subView(idx1);
// Combine blocks in underlying group
bordered_grp->fillB(*underlyingB);
// Create views for my blocks
std::vector<int> idx2(2);
for (int i=0; i<1; i++)
idx2[i] = w+i;
Teuchos::RCP<NOX::Abstract::MultiVector> my_B_x =
B.subView(idx2);
// Extract solution component from my_B and store in B
bordered_grp->extractSolutionComponent(*my_B, *my_B_x);
}
void
LOCA::Homotopy::DeflatedGroup::
fillA(NOX::Abstract::MultiVector& A) const
{
string callingFunction =
"LOCA::Homotopy::DeflatedGroup::fillA";
Teuchos::RCP<const NOX::Abstract::MultiVector> my_A =
underlyingF;
// If the underlying system isn't bordered, we're done
if (!isBordered) {
A = *my_A;
return;
}
// Create views for underlying group
int w = bordered_grp->getBorderedWidth();
std::vector<int> idx1(w);
for (int i=0; i<w; i++)
idx1[i] = i;
Teuchos::RCP<NOX::Abstract::MultiVector> underlyingA =
A.subView(idx1);
// Fill A block in underlying group
bordered_grp->fillA(*underlyingA);
// Create views for my blocks
std::vector<int> idx2(1);
for (int i=0; i<1; i++)
idx2[i] = w+i;
Teuchos::RCP<NOX::Abstract::MultiVector> my_A_x =
A.subView(idx2);
// Extract solution component from my_A and store in A
bordered_grp->extractSolutionComponent(*my_A, *my_A_x);
}
NOX::Abstract::Group::ReturnType
LOCA::Homotopy::Group::computeDfDpMulti(const vector<int>& paramIDs,
NOX::Abstract::MultiVector& dfdp,
bool isValidF)
{
// g = conParam * f(x) + ((1.0 - conParam) * (x - randomVec))
// dg/dp = f(x) - (x - randomVec) when p = conParam
// dg/dp = conParam * df/dp when p != conParam
// For simplicity, we always recompute g, even if isValidF is true
// Things get kind of messy otherwise
// Extract parameter IDs that are not the continuation parameter
vector<int> pIDs;
vector<int> idx(1);
idx[0] = 0; // index 0 corrsponds to f in dfdp
for (unsigned int i=0; i<paramIDs.size(); i++)
if (paramIDs[i] != conParamID) {
pIDs.push_back(paramIDs[i]);
idx.push_back(i+1);
}
// Create view of dfdp for parameters that aren't the continuation parameter
Teuchos::RCP<NOX::Abstract::MultiVector> fp =
dfdp.subView(idx);
// Compute df/dp for non-continuation parameter parameters
// We force recomputation of f for simplicity
NOX::Abstract::Group::ReturnType status =
grpPtr->computeDfDpMulti(pIDs, *fp, false);
// Compute conParam * df/dp
fp->scale(conParam);
// Compute g
double v = 1.0-conParam;
dfdp[0].update(v, grpPtr->getX(), -v, *randomVecPtr, 1.0);
// Compute dg/dp for p = conParam
grpPtr->computeF();
for (unsigned int i=0; i<paramIDs.size(); i++)
if (paramIDs[i] == conParamID) {
dfdp[i+1] = grpPtr->getF();
dfdp[i+1].update(-1.0, grpPtr->getX(), 1.0, *randomVecPtr, 1.0);
}
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::Thyra::Group::computeDfDpMulti(const std::vector<int>& paramIDs,
NOX::Abstract::MultiVector& fdfdp,
bool isValidF)
{
// Currently this does not work because the thyra modelevaluator is not
// setting the parameter names correctly in the epetraext modelevalator,
// so we are disabling this for now
implement_dfdp = false;
// Use default implementation if we don't want to use model evaluator, or
// it doesn't support it
if (!implement_dfdp ||
!out_args_.supports(::Thyra::ModelEvaluatorBase::OUT_ARG_DfDp,
param_index).supports(::Thyra::ModelEvaluatorBase::DERIV_MV_BY_COL)) {
NOX::Abstract::Group::ReturnType res =
LOCA::Abstract::Group::computeDfDpMulti(paramIDs, fdfdp, isValidF);
return res;
}
// Split fdfdp into f and df/dp
int num_vecs = fdfdp.numVectors()-1;
std::vector<int> index_dfdp(num_vecs);
for (int i=0; i<num_vecs; i++)
index_dfdp[i] = i+1;
NOX::Thyra::Vector& f = dynamic_cast<NOX::Thyra::Vector&>(fdfdp[0]);
Teuchos::RCP<NOX::Abstract::MultiVector> dfdp =
fdfdp.subView(index_dfdp);
// Right now this isn't very efficient because we have to compute
// derivatives with respect to all of the parameters, not just
// paramIDs. Will have to work out with Ross how to selectively get
// parameter derivatives
int np = params.length();
Teuchos::RCP<NOX::Thyra::MultiVector> dfdp_full =
Teuchos::rcp_dynamic_cast<NOX::Thyra::MultiVector>(dfdp->clone(np));
::Thyra::ModelEvaluatorBase::DerivativeMultiVector<double> dmv(dfdp_full->getThyraMultiVector(), ::Thyra::ModelEvaluatorBase::DERIV_MV_BY_COL);
::Thyra::ModelEvaluatorBase::Derivative<double> deriv(dmv);
in_args_.set_x(x_vec_->getThyraRCPVector().assert_not_null());
if (in_args_.supports(::Thyra::ModelEvaluatorBase::IN_ARG_x_dot))
in_args_.set_x_dot(x_dot_vec);
in_args_.set_p(param_index, param_thyra_vec);
if (!isValidF)
out_args_.set_f(f.getThyraRCPVector().assert_not_null());
out_args_.set_DfDp(param_index, deriv);
// Evaluate model
model_->evalModel(in_args_, out_args_);
// Copy back dfdp
for (int i=0; i<num_vecs; i++)
(*dfdp)[i] = (*dfdp_full)[paramIDs[i]];
// Reset inargs/outargs
in_args_.set_x(Teuchos::null);
in_args_.set_p(param_index, Teuchos::null);
out_args_.set_f(Teuchos::null);
out_args_.set_DfDp(param_index,
::Thyra::ModelEvaluatorBase::Derivative<double>());
if (out_args_.isFailed())
return NOX::Abstract::Group::Failed;
return NOX::Abstract::Group::Ok;
}
// Solves turning point equations via classic Salinger bordering
// The first m columns of input_x and input_null store the RHS while
// the last column stores df/dp, d(Jn)/dp respectively. Note however
// input_param has only m columns (not m+1). result_x, result_null,
// are result_param have the same dimensions as their input counterparts
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MooreSpence::PhippsBordering::solveTransposeContiguous(
Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input_x,
const NOX::Abstract::MultiVector& input_null,
const NOX::Abstract::MultiVector::DenseMatrix& input_param,
NOX::Abstract::MultiVector& result_x,
NOX::Abstract::MultiVector& result_null,
NOX::Abstract::MultiVector::DenseMatrix& result_param) const
{
std::string callingFunction =
"LOCA::TurningPoint::MooreSpence::PhippsBordering::solveTransposeContiguous()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
int m = input_x.numVectors()-2;
std::vector<int> index_input(m);
std::vector<int> index_input_dp(m+1);
std::vector<int> index_null(1);
std::vector<int> index_dp(1);
for (int i=0; i<m; i++) {
index_input[i] = i;
index_input_dp[i] = i;
}
index_input_dp[m] = m;
index_dp[0] = m;
index_null[0] = m+1;
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_1(1, m+1);
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_2(1, m+2);
// Create view of first m+1 columns of input_null, result_null
Teuchos::RCP<NOX::Abstract::MultiVector> input_null_view =
input_null.subView(index_input_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> result_null_view =
result_null.subView(index_input_dp);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J^T v||A B| = |G -phi|
// |u^T 0||a b| |0 0 |
status =
transposeBorderedSolver->applyInverseTranspose(params,
input_null_view.get(),
NULL,
*result_null_view,
tmp_mat_1);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> A =
result_null.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> B =
result_null.subView(index_dp);
double b = tmp_mat_1(0,m);
// compute (Jv)_x^T[A B u]
result_null[m+1] = *uVector;
Teuchos::RCP<NOX::Abstract::MultiVector> tmp =
result_null.clone(NOX::ShapeCopy);
status = group->computeDwtJnDxMulti(result_null, *nullVector, *tmp);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// compute [F 0 0] - (Jv)_x^T[A B u]
tmp->update(1.0, input_x, -1.0);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J^T v||C D E| = |F - (Jv)_x^T A -(Jv)_x^T B -(Jv)_x^T u|
// |u^T 0||c d e| | 0 0 0 |
status =
transposeBorderedSolver->applyInverseTranspose(params,
tmp.get(),
NULL,
result_x,
tmp_mat_2);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> C =
result_x.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> D =
result_x.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> E =
result_x.subView(index_null);
double d = tmp_mat_2(0, m);
double e = tmp_mat_2(0, m+1);
// compute (Jv)_p^T*[A B u]
NOX::Abstract::MultiVector::DenseMatrix t1(1,m+2);
result_null.multiply(1.0, *dJndp, t1);
// compute f_p^T*[C D E]
NOX::Abstract::MultiVector::DenseMatrix t2(1,m+2);
result_x.multiply(1.0, *dfdp, t2);
// compute f_p^T*u
double fptu = uVector->innerProduct((*dfdp)[0]);
// Fill coefficient arrays
double M[9];
M[0] = st; M[1] = -e; M[2] = t1(0,m+1) + t2(0,m+1);
M[3] = 0.0; M[4] = st; M[5] = fptu;
M[6] = -b; M[7] = -d; M[8] = t1(0,m) + t2(0,m);
// Compute RHS
double *R = new double[3*m];
for (int i=0; i<m; i++) {
R[3*i] = tmp_mat_1(0,i);
R[3*i+1] = tmp_mat_2(0,i);
R[3*i+2] = result_param(0,i) - t1(0,i) - t2(0,i);
}
// Solve M*P = R
int three = 3;
int piv[3];
int info;
Teuchos::LAPACK<int,double> L;
L.GESV(three, m, M, three, piv, R, three, &info);
if (info != 0) {
globalData->locaErrorCheck->throwError(
callingFunction,
"Solve of 3x3 coefficient matrix failed!");
return NOX::Abstract::Group::Failed;
}
NOX::Abstract::MultiVector::DenseMatrix alpha(1,m);
NOX::Abstract::MultiVector::DenseMatrix beta(1,m);
for (int i=0; i<m; i++) {
alpha(0,i) = R[3*i];
beta(0,i) = R[3*i+1];
result_param(0,i) = R[3*i+2];
}
// compute A = A + B*z + alpha*u (remember A is a sub-view of result_null)
A->update(Teuchos::NO_TRANS, 1.0, *B, result_param, 1.0);
A->update(Teuchos::NO_TRANS, 1.0, *uMultiVector, alpha, 1.0);
// compute C = C + D*z + alpha*E + beta*u
// (remember C is a sub-view of result_x)
C->update(Teuchos::NO_TRANS, 1.0, *D, result_param, 1.0);
C->update(Teuchos::NO_TRANS, 1.0, *E, alpha, 1.0);
C->update(Teuchos::NO_TRANS, 1.0, *uMultiVector, beta, 1.0);
delete [] R;
return finalStatus;
}
// Solves turning point equations via Phipps modified bordering
// The first m columns of input_x and input_null store the RHS while
// the last column stores df/dp, d(Jn)/dp respectively. Note however
// input_param has only m columns (not m+1). result_x, result_null,
// are result_param have the same dimensions as their input counterparts
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MooreSpence::PhippsBordering::solveContiguous(
Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input_x,
const NOX::Abstract::MultiVector& input_null,
const NOX::Abstract::MultiVector::DenseMatrix& input_param,
NOX::Abstract::MultiVector& result_x,
NOX::Abstract::MultiVector& result_null,
NOX::Abstract::MultiVector::DenseMatrix& result_param) const
{
std::string callingFunction =
"LOCA::TurningPoint::MooreSpence::PhippsBordering::solveContiguous()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
int m = input_x.numVectors()-2;
std::vector<int> index_input(m);
std::vector<int> index_input_dp(m+1);
std::vector<int> index_null(1);
std::vector<int> index_dp(1);
for (int i=0; i<m; i++) {
index_input[i] = i;
index_input_dp[i] = i;
}
index_input_dp[m] = m;
index_dp[0] = m;
index_null[0] = m+1;
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_1(1, m+1);
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_2(1, m+2);
// Create view of first m+1 columns of input_x, result_x
Teuchos::RCP<NOX::Abstract::MultiVector> input_x_view =
input_x.subView(index_input_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> result_x_view =
result_x.subView(index_input_dp);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J u||A B| = |F df/dp|
// |v^T 0||a b| |0 0 |
status = borderedSolver->applyInverse(params, input_x_view.get(), NULL,
*result_x_view, tmp_mat_1);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> A =
result_x.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> B =
result_x.subView(index_dp);
double b = tmp_mat_1(0,m);
// compute (Jv)_x[A B v]
result_x[m+1] = *nullVector;
Teuchos::RCP<NOX::Abstract::MultiVector> tmp =
result_x.clone(NOX::ShapeCopy);
status = group->computeDJnDxaMulti(*nullVector, *JnVector, result_x,
*tmp);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute (Jv)_x[A B v] - [G d(Jn)/dp 0]
tmp->update(-1.0, input_null, 1.0);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J u||C D E| = |(Jv)_x A - G (Jv)_x B - d(Jv)/dp (Jv)_x v|
// |v^T 0||c d e| | 0 0 0 |
status = borderedSolver->applyInverse(params, tmp.get(), NULL, result_null,
tmp_mat_2);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> C =
result_null.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> D =
result_null.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> E =
result_null.subView(index_null);
double d = tmp_mat_2(0, m);
double e = tmp_mat_2(0, m+1);
// Fill coefficient arrays
double M[9];
M[0] = s; M[1] = e; M[2] = -tpGroup->lTransNorm((*E)[0]);
M[3] = 0.0; M[4] = s; M[5] = tpGroup->lTransNorm(*nullVector);
M[6] = b; M[7] = -d; M[8] = tpGroup->lTransNorm((*D)[0]);
// compute h + phi^T C
tpGroup->lTransNorm(*C, result_param);
result_param += input_param;
double *R = new double[3*m];
for (int i=0; i<m; i++) {
R[3*i] = tmp_mat_1(0,i);
R[3*i+1] = -tmp_mat_2(0,i);
R[3*i+2] = result_param(0,i);
}
// Solve M*P = R
int three = 3;
int piv[3];
int info;
Teuchos::LAPACK<int,double> L;
L.GESV(three, m, M, three, piv, R, three, &info);
if (info != 0) {
globalData->locaErrorCheck->throwError(
callingFunction,
"Solve of 3x3 coefficient matrix failed!");
return NOX::Abstract::Group::Failed;
}
NOX::Abstract::MultiVector::DenseMatrix alpha(1,m);
NOX::Abstract::MultiVector::DenseMatrix beta(1,m);
for (int i=0; i<m; i++) {
alpha(0,i) = R[3*i];
beta(0,i) = R[3*i+1];
result_param(0,i) = R[3*i+2];
}
// compute A = A - B*z + v*alpha (remember A is a sub-view of result_x)
A->update(Teuchos::NO_TRANS, -1.0, *B, result_param, 1.0);
A->update(Teuchos::NO_TRANS, 1.0, *nullMultiVector, alpha, 1.0);
// compute C = -C + d*z - E*alpha + v*beta
// (remember C is a sub-view of result_null)
C->update(Teuchos::NO_TRANS, 1.0, *D, result_param, -1.0);
C->update(Teuchos::NO_TRANS, -1.0, *E, alpha, 1.0);
C->update(Teuchos::NO_TRANS, 1.0, *nullMultiVector, beta, 1.0);
delete [] R;
return finalStatus;
}
// Solves Hopf equations via classic Salinger bordering
// The first m columns of input_x, input_y, input_z store the RHS, the
// next column stores df/dp, (Jy-wBz)_p and (Jz+wBy)_p respectively, the
// last column of input_y and input_z store Bz and -By respectively. Note
// input_x has m+1 columns, input_y and input_z have m+2, and input_w and
// input_p have m columns. result_x, result_y, result_z, result_w and
// result_param have the same dimensions as their input counterparts
NOX::Abstract::Group::ReturnType
LOCA::Hopf::MooreSpence::SalingerBordering::solveContiguous(
Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input_x,
const NOX::Abstract::MultiVector& input_y,
const NOX::Abstract::MultiVector& input_z,
const NOX::Abstract::MultiVector::DenseMatrix& input_w,
const NOX::Abstract::MultiVector::DenseMatrix& input_p,
NOX::Abstract::MultiVector& result_x,
NOX::Abstract::MultiVector& result_y,
NOX::Abstract::MultiVector& result_z,
NOX::Abstract::MultiVector::DenseMatrix& result_w,
NOX::Abstract::MultiVector::DenseMatrix& result_p) const
{
std::string callingFunction =
"LOCA::Hopf::MooreSpence::SalingerBordering::solveContiguous()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
int m = input_x.numVectors()-1;
std::vector<int> index_input(m);
std::vector<int> index_dp(1);
std::vector<int> index_B(1);
std::vector<int> index_ip(m+1);
for (int i=0; i<m; i++) {
index_input[i] = i;
index_ip[i] = i;
}
index_ip[m] = m;
index_dp[0] = m;
index_B[0] = m+1;
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// compute [A b] = J^-1 [F df/dp]
status = group->applyJacobianInverseMultiVector(params, input_x, result_x);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> A =
result_x.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> b =
result_x.subView(index_dp);
// verify underlying complex matrix is valid
if (!group->isComplex()) {
status = group->computeComplex(w);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// compute (J+iwB)(y+iz)_x [A b]
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_real =
result_y.clone(NOX::ShapeCopy);
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_real_sub =
tmp_real->subView(index_ip);
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_imag =
result_y.clone(NOX::ShapeCopy);
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_imag_sub =
tmp_imag->subView(index_ip);
tmp_real->init(0.0);
tmp_imag->init(0.0);
status = group->computeDCeDxa(*yVector, *zVector, w, result_x,
*CeRealVector, *CeImagVector, *tmp_real_sub,
*tmp_imag_sub);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute [G+iH d(J+iwB)(y+iz)/dp iB(y+iz)] - [(J+iwB)_x[A b] 0+i0]
tmp_real->update(1.0, input_y, -1.0);
tmp_imag->update(1.0, input_z, -1.0);
// verify underlying complex matrix is valid
if (!group->isComplex()) {
status = group->computeComplex(w);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// compute [C+iD e+if g+ih] = (J+iwB)^-1 (tmp_real + i tmp_imag)
status = group->applyComplexInverseMultiVector(params, *tmp_real, *tmp_imag,
result_y, result_z);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> C =
result_y.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> D =
result_z.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> e =
result_y.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> f =
result_z.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> g =
result_y.subView(index_B);
Teuchos::RCP<NOX::Abstract::MultiVector> h =
result_z.subView(index_B);
// compute lambda = ((phi^T h)(phi^T C-u) - (phi^T g)(phi^T D-v)) /
// ((phi^T h)(phi^T e)-(phi^T g)(phi^T f))
NOX::Abstract::MultiVector::DenseMatrix ltC(1,m);
NOX::Abstract::MultiVector::DenseMatrix ltD(1,m);
double lte = hopfGroup->lTransNorm((*e)[0]);
double ltf = hopfGroup->lTransNorm((*f)[0]);
double ltg = hopfGroup->lTransNorm((*g)[0]);
double lth = hopfGroup->lTransNorm((*h)[0]);
double denom = lth*lte - ltg*ltf;
hopfGroup->lTransNorm(*C, ltC);
ltC -= input_w;
ltC.scale(lth);
hopfGroup->lTransNorm(*D, ltD);
ltD -= input_p;
result_p.assign(ltD);
result_p.scale(-ltg);
result_p += ltC;
result_p.scale(1.0/denom);
// compute omega = (phi^T D-v - (phi^T f)lambda)/(phi^T h)
result_w.assign(result_p);
result_w.scale(-ltf);
result_w += ltD;
result_w.scale(1.0/lth);
// compute A = A - b*lambda (remember A is a sub-view of result_x)
A->update(Teuchos::NO_TRANS, -1.0, *b, result_p, 1.0);
// compute C = C - e*lambda - g*omega (remember C is a sub-view of result_y)
C->update(Teuchos::NO_TRANS, -1.0, *e, result_p, 1.0);
C->update(Teuchos::NO_TRANS, -1.0, *g, result_w, 1.0);
// compute D = D - f*lambda - h*omega (remember D is a sub-view of result_z)
D->update(Teuchos::NO_TRANS, -1.0, *f, result_p, 1.0);
D->update(Teuchos::NO_TRANS, -1.0, *h, result_w, 1.0);
return finalStatus;
}
void
LOCA::BorderedSolver::HouseholderQR::computeQR(
const NOX::Abstract::MultiVector::DenseMatrix& C,
const NOX::Abstract::MultiVector& B,
bool use_c_transpose,
NOX::Abstract::MultiVector::DenseMatrix& Y1,
NOX::Abstract::MultiVector& Y2,
NOX::Abstract::MultiVector::DenseMatrix& T,
NOX::Abstract::MultiVector::DenseMatrix& R)
{
double beta;
int m = B.numVectors();
// Initialize
Y1.putScalar(0.0);
T.putScalar(0.0);
Y2 = B;
if (use_c_transpose) {
for (int i=0; i<m; i++)
for (int j=0; j<m; j++)
R(i,j) = C(j,i); // Copy transpose of C into R
}
else
R.assign(C);
// A temporary vector
Teuchos::RCP<NOX::Abstract::MultiVector> v2 = Y2.clone(1);
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> v1;
Teuchos::RCP<NOX::Abstract::MultiVector> h2;
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> h1;
Teuchos::RCP<NOX::Abstract::MultiVector> y2;
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> y1;
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> z;
std::vector<int> h_idx;
std::vector<int> y_idx;
y_idx.reserve(m);
for (int i=0; i<m; i++) {
// Create view of column i of Y1 starting at row i
v1 =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
Y1,
m-i,
1, i, i));
// Create view of columns i through m-1 of Y2
h_idx.resize(m-i);
for (unsigned int j=0; j<h_idx.size(); j++)
h_idx[j] = i+j;
h2 = Y2.subView(h_idx);
// Create view of columns i thru m-1 of R, starting at row i
h1 =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
R,
m-i,
m-i,
i, i));
if (i > 0) {
// Create view of columns 0 through i-1 of Y2
y_idx.push_back(i-1);
y2 = Y2.subView(y_idx);
// Create view of columns 0 through i-1 of Y1, starting at row i
y1 =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
Y1,
m-i,
i, i, 0));
// Create view of column i, row 0 through i-1 of T
z =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
T,
i,
1,
0, i));
}
// Compute Householder Vector
computeHouseholderVector(i, R, Y2, *v1, *v2, beta);
// Apply Householder reflection
applyHouseholderVector(*v1, *v2, beta, *h1, *h2);
// Copy v2 into Y2
Y2[i] = (*v2)[0];
T(i,i) = -beta;
if (i > 0) {
// Compute z = y2^T * v2
v2->multiply(1.0, *y2, *z);
// Compute z = -beta * (z + y1^T * v1)
z->multiply(Teuchos::TRANS, Teuchos::NO_TRANS, -beta, *y1, *v1, -beta);
// Compute z = T * z
dblas.TRMV(Teuchos::UPPER_TRI, Teuchos::NO_TRANS, Teuchos::NON_UNIT_DIAG,
i, T.values(), m, z->values(), 1);
}
}
}
// Solves pitchfork equations via Phipps modified bordering
// The first m columns of input_x and input_null store the RHS,
// column m+1 stores df/dp, d(Jn)/dp, column m+2 stores psi and 0,
// and the last column provides space for solving (Jv_x) v. Note however
// input_param has only m columns. result_x, result_null,
// are result_param have the same dimensions as their input counterparts
NOX::Abstract::Group::ReturnType
LOCA::Pitchfork::MooreSpence::PhippsBordering::solveContiguous(
Teuchos::ParameterList& params,
const NOX::Abstract::MultiVector& input_x,
const NOX::Abstract::MultiVector& input_null,
const NOX::Abstract::MultiVector::DenseMatrix& input_slack,
const NOX::Abstract::MultiVector::DenseMatrix& input_param,
NOX::Abstract::MultiVector& result_x,
NOX::Abstract::MultiVector& result_null,
NOX::Abstract::MultiVector::DenseMatrix& result_slack,
NOX::Abstract::MultiVector::DenseMatrix& result_param) const
{
string callingFunction =
"LOCA::Pitchfork::MooreSpence::PhippsBordering::solveContiguous()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
int m = input_x.numVectors()-3;
vector<int> index_input(m);
vector<int> index_input_dp(m+2);
vector<int> index_null(1);
vector<int> index_dp(1);
vector<int> index_s(1);
for (int i=0; i<m; i++) {
index_input[i] = i;
index_input_dp[i] = i;
}
index_input_dp[m] = m;
index_input_dp[m+1] = m+1;
index_dp[0] = m;
index_s[0] = m+1;
index_null[0] = m+2;
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_1(1, m+2);
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_2(1, m+3);
// Create view of first m+2 columns of input_x, result_x
Teuchos::RCP<NOX::Abstract::MultiVector> input_x_view =
input_x.subView(index_input_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> result_x_view =
result_x.subView(index_input_dp);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J u||A B C| = |F df/dp psi|
// |v^T 0||a b c| |0 0 0 |
status = borderedSolver->applyInverse(params, input_x_view.get(), NULL,
*result_x_view, tmp_mat_1);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> A =
result_x.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> B =
result_x.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> C =
result_x.subView(index_s);
double b = tmp_mat_1(0,m);
double c = tmp_mat_1(0,m+1);
// compute (Jv)_x[A B C v]
result_x[m+2] = *nullVector;
Teuchos::RCP<NOX::Abstract::MultiVector> tmp =
result_x.clone(NOX::ShapeCopy);
status = group->computeDJnDxaMulti(*nullVector, *JnVector, result_x,
*tmp);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
// compute [G d(Jn)/dp 0 0] - (Jv)_x[A B C v]
tmp->update(1.0, input_null, -1.0);
// verify underlying Jacobian is valid
if (!group->isJacobian()) {
status = group->computeJacobian();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Solve |J u||D E K L| = |G-(Jv)_xA d(Jv)/dp-(Jv)_xB -(Jv)_xC -(Jv)_xv|
// |v^T 0||d e k l| | 0 0 0 0 |
status = borderedSolver->applyInverse(params, tmp.get(), NULL, result_null,
tmp_mat_2);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
callingFunction);
Teuchos::RCP<NOX::Abstract::MultiVector> D =
result_null.subView(index_input);
Teuchos::RCP<NOX::Abstract::MultiVector> E =
result_null.subView(index_dp);
Teuchos::RCP<NOX::Abstract::MultiVector> K =
result_null.subView(index_s);
Teuchos::RCP<NOX::Abstract::MultiVector> L =
result_null.subView(index_null);
double e = tmp_mat_2(0, m);
double k = tmp_mat_2(0, m+1);
double l = tmp_mat_2(0, m+2);
double ltE = pfGroup->lTransNorm((*E)[0]);
double ltK = pfGroup->lTransNorm((*K)[0]);
double ltL = pfGroup->lTransNorm((*L)[0]);
double ltv = pfGroup->lTransNorm(*nullVector);
double ipv = group->innerProduct(*nullVector, *asymVector);
double ipB = group->innerProduct((*B)[0], *asymVector);
double ipC = group->innerProduct((*C)[0], *asymVector);
// Fill coefficient arrays
double M[16];
M[0] = sigma; M[1] = -l; M[2] = ipv; M[3] = ltL;
M[4] = 0.0; M[5] = sigma; M[6] = 0.0; M[7] = ltv;
M[8] = b; M[9] = e; M[10] = -ipB; M[11] = -ltE;
M[12] = c; M[13] = k; M[14] = -ipC; M[15] = -ltK;
// compute s - <A,psi>
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_3(1, m);
group->innerProduct(*asymMultiVector, *A, tmp_mat_3);
tmp_mat_3 -= input_slack;
tmp_mat_3.scale(-1.0);
// compute h - phi^T D
NOX::Abstract::MultiVector::DenseMatrix tmp_mat_4(1, m);
pfGroup->lTransNorm(*D, tmp_mat_4);
tmp_mat_4 -= input_param;
tmp_mat_4.scale(-1.0);
double *R = new double[4*m];
for (int i=0; i<m; i++) {
R[4*i] = tmp_mat_1(0,i);
R[4*i+1] = tmp_mat_2(0,i);
R[4*i+2] = tmp_mat_3(0,i);
R[4*i+3] = tmp_mat_4(0,i);
}
// Solve M*P = R
int piv[4];
int info;
Teuchos::LAPACK<int,double> dlapack;
dlapack.GESV(4, m, M, 4, piv, R, 4, &info);
if (info != 0) {
globalData->locaErrorCheck->throwError(
callingFunction,
"Solve of 4x4 coefficient matrix failed!");
return NOX::Abstract::Group::Failed;
}
NOX::Abstract::MultiVector::DenseMatrix alpha(1,m);
NOX::Abstract::MultiVector::DenseMatrix beta(1,m);
for (int i=0; i<m; i++) {
alpha(0,i) = R[4*i];
beta(0,i) = R[4*i+1];
result_param(0,i) = R[4*i+2];
result_slack(0,i) = R[4*i+3];
}
// compute A = A - B*z -C*w + v*alpha (remember A is a sub-view of result_x)
A->update(Teuchos::NO_TRANS, -1.0, *B, result_param, 1.0);
A->update(Teuchos::NO_TRANS, -1.0, *C, result_slack, 1.0);
A->update(Teuchos::NO_TRANS, 1.0, *nullMultiVector, alpha, 1.0);
// compute D = D - E*z - K*w + L*alpha + v*beta
// (remember D is a sub-view of result_null)
D->update(Teuchos::NO_TRANS, -1.0, *E, result_param, 1.0);
D->update(Teuchos::NO_TRANS, -1.0, *K, result_slack, 1.0);
D->update(Teuchos::NO_TRANS, 1.0, *L, alpha, 1.0);
D->update(Teuchos::NO_TRANS, 1.0, *nullMultiVector, beta, 1.0);
delete [] R;
return finalStatus;
}