void
LOCA::Homotopy::DeflatedGroup::
extractParameterComponent(bool use_transpose,
const NOX::Abstract::MultiVector& v,
NOX::Abstract::MultiVector::DenseMatrix& v_p) const
{
// cast v to an extended multi-vec
const LOCA::MultiContinuation::ExtendedMultiVector& mc_v =
dynamic_cast<const LOCA::MultiContinuation::ExtendedMultiVector&>(v);
// get solution and parameter components
Teuchos::RCP<const NOX::Abstract::MultiVector> mc_v_x =
mc_v.getXMultiVec();
Teuchos::RCP<const NOX::Abstract::MultiVector::DenseMatrix> mc_v_p =
mc_v.getScalars();
// If the underlying system isn't bordered, we're done
if (!isBordered) {
if (!use_transpose)
v_p.assign(*mc_v_p);
else
for (int j=0; j<v_p.numCols(); j++)
for (int i=0; i<v_p.numRows(); i++)
v_p(i,j) = (*mc_v_p)(j,i);
return;
}
int w = bordered_grp->getBorderedWidth();
if (!use_transpose) {
// Split v_p into 2 block rows, the top to store mc_v_x_p and the bottom
// to store mc_v_p
int num_cols = v_p.numCols();
NOX::Abstract::MultiVector::DenseMatrix v_p_1(Teuchos::View, v_p,
w, num_cols, 0, 0);
NOX::Abstract::MultiVector::DenseMatrix v_p_2(Teuchos::View, v_p,
1, num_cols, w, 0);
// Decompose mc_v_x
bordered_grp->extractParameterComponent(use_transpose,*mc_v_x, v_p_1);
v_p_2.assign(*mc_v_p);
}
else {
// Split v_p into 2 block columns, the first to store mc_v_x_p^t and the
// the second to store mc_v_p^T
int num_rows = v_p.numRows();
NOX::Abstract::MultiVector::DenseMatrix v_p_1(Teuchos::View, v_p,
num_rows, w, 0, 0);
NOX::Abstract::MultiVector::DenseMatrix v_p_2(Teuchos::View, v_p,
num_rows, 1, 0, w);
// Decompose mc_v_x
bordered_grp->extractParameterComponent(use_transpose,*mc_v_x, v_p_1);
for (int j=0; j<1; j++)
for (int i=0; i<num_rows; i++)
v_p_2(i,j) = (*mc_v_p)(j,i);
}
}
void
LOCA::Extended::MultiVector::multiply(
double alpha,
const LOCA::Extended::MultiVector& y,
NOX::Abstract::MultiVector::DenseMatrix& b) const
{
// Verify dimensions are consistent
if (y.numMultiVecRows != numMultiVecRows || y.numColumns != b.numRows() ||
y.numScalarRows != numScalarRows || numColumns != b.numCols())
globalData->locaErrorCheck->throwError(
"LOCA::Extended::MultiVector::multiply()",
"Size of supplied multivector/matrix is incompatible with this multivector");
// Zero out b
b.putScalar(0.0);
// Create temporary matrix to hold product for each multivec
NOX::Abstract::MultiVector::DenseMatrix tmp(b);
// Compute and sum products for each multivec
for (int i=0; i<numMultiVecRows; i++) {
multiVectorPtrs[i]->multiply(alpha, *(y.multiVectorPtrs[i]), tmp);
b += tmp;
}
// Compute and add in product for scalars
if (numScalarRows > 0)
b.multiply(Teuchos::TRANS, Teuchos::NO_TRANS, alpha, *y.scalarsPtr,
*scalarsPtr, 1.0);
}
int
NOX::TestCompare::testMatrix(
const NOX::Abstract::MultiVector::DenseMatrix& mat,
const NOX::Abstract::MultiVector::DenseMatrix& mat_expected,
double rtol, double atol,
const std::string& name)
{
bool passed;
NOX::Abstract::MultiVector::DenseMatrix tmp(mat_expected.numRows(),
mat_expected.numCols());
for (int j=0; j<mat_expected.numCols(); j++)
for (int i=0; i<mat_expected.numRows(); i++)
tmp(i,j) = fabs(mat(i,j)-mat_expected(i,j)) /
(atol + rtol * fabs(mat_expected(i,j)));
double inf_norm = tmp.normInf();
if (inf_norm < 1)
passed = true;
else
passed = false;
if (utils.isPrintType(NOX::Utils::TestDetails)) {
os << std::endl
<< "\tChecking " << name << ": ";
if (passed)
os << "Passed." << std::endl;
else
os << "Failed." << std::endl;
os << "\t\tComputed norm: " << utils.sciformat(inf_norm)
<< std::endl
<< "\t\tRelative Tolerance: " << utils.sciformat(rtol)
<< std::endl
<< "\t\tAbsolute Tolerance: " << utils.sciformat(rtol)
<< std::endl;
}
if (passed)
return 0;
else
return 1;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::CompositeConstraint::multiplyDX(
double alpha,
const NOX::Abstract::MultiVector& input_x,
NOX::Abstract::MultiVector::DenseMatrix& result_p) const
{
std::string callingFunction =
"LOCA::MultiContinuation::CompositeConstraint::multiplyDX()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// If dg/dx is zero for every constraint, result_p is zero
if (isDXZero()) {
result_p.putScalar(0.0);
return finalStatus;
}
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> result_p_sub;
int num_rows;
int num_cols = result_p.numCols();
for (int i=0; i<numConstraintObjects; i++) {
num_rows = constraintPtrs[i]->numConstraints();
// if dg/dx is zero for this constraint, set corresponding entries of
// result_p to zero
if (constraintPtrs[i]->isDXZero()) {
for (int j=0; j<num_rows; j++)
for (int k=0; k<num_cols; k++)
result_p(indices[i][j],k) = 0.0;
}
else {
// Create a sub view of rows indices[i][0] -- indices[i][end]
// of result_p
result_p_sub =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
result_p,
num_rows,
num_cols,
indices[i][0],
0));
status = constraintPtrs[i]->multiplyDX(alpha, input_x,
*result_p_sub);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
}
return finalStatus;
}
void
NOX::Thyra::MultiVector::
multiply(double alpha,
const NOX::Abstract::MultiVector& y,
NOX::Abstract::MultiVector::DenseMatrix& b) const
{
const NOX::Thyra::MultiVector& yy =
dynamic_cast<const NOX::Thyra::MultiVector&>(y);
int m = b.numRows();
int n = b.numCols();
Teuchos::RCP< ::Thyra::MultiVectorBase<double> > bb =
::Thyra::createMembersView(
yy.thyraMultiVec->domain(),
RTOpPack::SubMultiVectorView<double>(0, m, 0, n,
Teuchos::arcp(b.values(), 0, b.stride()*b.numCols(), false),
b.stride()
)
);
::Thyra::apply(*yy.thyraMultiVec, ::Thyra::CONJTRANS, *thyraMultiVec,
bb.ptr(), alpha, 0.0);
}
// =============================================================================
// Compute result_p = alpha * dg/dx * input_x.
NOX::Abstract::Group::ReturnType
Ginla::FDM::Constraint::MinDist::
multiplyDX ( double alpha,
const NOX::Abstract::MultiVector & input_x,
NOX::Abstract::MultiVector::DenseMatrix & result_p
) const
{
TEUCHOS_ASSERT( komplex_.is_valid_ptr() && !komplex_.is_null() );
TEUCHOS_ASSERT_EQUALITY( result_p.numCols(), input_x.numVectors() );
for ( int k=0; k<input_x.numVectors(); k++ )
{
const Epetra_Vector & xE =
Teuchos::dyn_cast<const NOX::Epetra::Vector>( input_x[0] ).getEpetraVector();
Teuchos::RCP<ComplexVector> xPsi = komplex_->real2complex( xE );
result_p(0,k) = alpha * std::imag( psiRef_->dot(*xPsi) );
}
return NOX::Abstract::Group::Ok;
}
void
LOCA::Homotopy::DeflatedGroup::
loadNestedComponents(const NOX::Abstract::MultiVector& v_x,
const NOX::Abstract::MultiVector::DenseMatrix& v_p,
NOX::Abstract::MultiVector& v) const
{
// cast X to an extended multi-vec
LOCA::MultiContinuation::ExtendedMultiVector& mc_v =
dynamic_cast<LOCA::MultiContinuation::ExtendedMultiVector&>(v);
// get solution and parameter components
Teuchos::RCP<NOX::Abstract::MultiVector> mc_v_x =
mc_v.getXMultiVec();
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> mc_v_p =
mc_v.getScalars();
// If the underlying system isn't bordered, we're done
if (!isBordered) {
*mc_v_x = v_x;
mc_v_p->assign(v_p);
return;
}
// split v_p
int num_cols = v_p.numCols();
int w = bordered_grp->getBorderedWidth();
NOX::Abstract::MultiVector::DenseMatrix v_p_1(Teuchos::View, v_p,
w, num_cols, 0, 0);
NOX::Abstract::MultiVector::DenseMatrix v_p_2(Teuchos::View, v_p,
1, num_cols, w, 0);
// load v_x, v_p_1 into mc_v_x
bordered_grp->loadNestedComponents(v_x, v_p_1, *mc_v_x);
// load v_p_2 into mc_v_p
mc_v_p->assign(v_p_2);
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::CompositeConstraint::computeDP(
const std::vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
std::string callingFunction =
"LOCA::MultiContinuation::CompositeConstraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
Teuchos::RCP<NOX::Abstract::MultiVector::DenseMatrix> dgdp_sub;
int num_rows;
int num_cols = dgdp.numCols();
for (int i=0; i<numConstraintObjects; i++) {
// Create a sub view of rows indices[i][0] -- indices[i][end] of dgdp
num_rows = indices[i][constraintPtrs[i]->numConstraints()-1] -
indices[i][0] + 1;
dgdp_sub =
Teuchos::rcp(new NOX::Abstract::MultiVector::DenseMatrix(Teuchos::View,
dgdp,
num_rows,
num_cols,
indices[i][0],
0));
status = constraintPtrs[i]->computeDP(paramIDs, *dgdp_sub, isValidG);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::BorderedSolver::LowerTriangularBlockElimination::
solve(Teuchos::ParameterList& params,
const LOCA::BorderedSolver::AbstractOperator& op,
const LOCA::MultiContinuation::ConstraintInterface& B,
const NOX::Abstract::MultiVector::DenseMatrix& C,
const NOX::Abstract::MultiVector* F,
const NOX::Abstract::MultiVector::DenseMatrix* G,
NOX::Abstract::MultiVector& X,
NOX::Abstract::MultiVector::DenseMatrix& Y) const
{
string callingFunction =
"LOCA::BorderedSolver::LowerTriangularBlockElimination::solve()";
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
NOX::Abstract::Group::ReturnType status;
// Determine if X or Y is zero
bool isZeroF = (F == NULL);
bool isZeroG = (G == NULL);
bool isZeroB = B.isDXZero();
bool isZeroX = isZeroF;
bool isZeroY = isZeroG && (isZeroB || isZeroX);
// First compute X
if (isZeroX)
X.init(0.0);
else {
// Solve X = J^-1 F, note F must be nonzero
status = op.applyInverse(params, *F, X);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Now compute Y
if (isZeroY)
Y.putScalar(0.0);
else {
// Compute G - B^T*X and store in Y
if (isZeroG)
B.multiplyDX(-1.0, X, Y);
else {
Y.assign(*G);
if (!isZeroB && !isZeroX) {
NOX::Abstract::MultiVector::DenseMatrix T(Y.numRows(),Y.numCols());
B.multiplyDX(1.0, X, T);
Y -= T;
}
}
// Overwrite Y with Y = C^-1 * (G - B^T*X)
NOX::Abstract::MultiVector::DenseMatrix M(C);
int *ipiv = new int[M.numRows()];
Teuchos::LAPACK<int,double> L;
int info;
L.GETRF(M.numRows(), M.numCols(), M.values(), M.stride(), ipiv, &info);
if (info != 0) {
status = NOX::Abstract::Group::Failed;
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
L.GETRS('N', M.numRows(), Y.numCols(), M.values(), M.stride(), ipiv,
Y.values(), Y.stride(), &info);
delete [] ipiv;
if (info != 0) {
status = NOX::Abstract::Group::Failed;
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(
status,
finalStatus,
callingFunction);
}
}
return finalStatus;
}
