void observeSolution(
const Epetra_Vector& solution)
{
double norm; solution.Norm2(&norm);
if (solution.Comm().MyPID()==0)
std::cout << "ObserveSolution: Norm = " << norm << std::endl;
}
int power_method(bool TransA, Epetra_RowMatrix& A, Epetra_Vector& q, Epetra_Vector& z0,
Epetra_Vector& resid, double* lambda, int niters, double tolerance, bool verbose)
{
// Fill z with random Numbers
Epetra_Vector z(z0);
// variable needed for iteration
double normz, residual;
int ierr = 1;
for(int iter = 0; iter < niters; iter++) {
z.Norm2(&normz); // Compute 2-norm of z
q.Scale(1.0/normz, z);
A.Multiply(TransA, q, z); // Compute z = A*q // SEGFAULT HAPPENS HERE
q.Dot(z, lambda); // Approximate maximum eigenvaluE
if(iter%100==0 || iter+1==niters) {
resid.Update(1.0, z, -(*lambda), q, 0.0); // Compute A*q - lambda*q
resid.Norm2(&residual);
if(verbose) cout << "Iter = " << iter << " Lambda = " << *lambda
<< " Residual of A*q - lambda*q = " << residual << endl;
}
if(residual < tolerance) {
ierr = 0;
break;
}
}
return(ierr);
}
//=============================================================================
double Epetra_MsrMatrix::NormOne() const {
if (NormOne_>-1.0) return(NormOne_);
if (!Filled()) EPETRA_CHK_ERR(-1); // Matrix must be filled.
Epetra_Vector * x = new Epetra_Vector(RowMatrixRowMap()); // Need temp vector for column sums
Epetra_Vector * xp = 0;
Epetra_Vector * x_tmp = 0;
// If we have a non-trivial importer, we must export elements that are permuted or belong to other processors
if (RowMatrixImporter()!=0) {
x_tmp = new Epetra_Vector(RowMatrixColMap()); // Create temporary import vector if needed
xp = x_tmp;
}
int i, j;
for (i=0; i < NumMyCols_; i++) (*xp)[i] = 0.0;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = GetRow(i);
for (j=0; j < NumEntries; j++) (*xp)[Indices_[j]] += fabs(Values_[j]);
}
if (RowMatrixImporter()!=0) x->Export(*x_tmp, *RowMatrixImporter(), Add); // Fill x with Values from temp vector
x->MaxValue(&NormOne_); // Find max
if (x_tmp!=0) delete x_tmp;
delete x;
UpdateFlops(NumGlobalNonzeros());
return(NormOne_);
}
void
Albany::SolutionMaxValueResponseFunction::
computeMaxValue(const Epetra_Vector& x, double& global_max, int& global_index)
{
double my_max = -Epetra_MaxDouble;
int my_index = -1, index;
// Loop over nodes to find max value for equation eq
int num_my_nodes = x.MyLength() / neq;
for (int node=0; node<num_my_nodes; node++) {
if (interleavedOrdering) index = node*neq+eq;
else index = node + eq*num_my_nodes;
if (x[index] > my_max) {
my_max = x[index];
my_index = index;
}
}
// Get max value across all proc's
x.Comm().MaxAll(&my_max, &global_max, 1);
// Compute min of all global indices equal to max value
if (my_max == global_max)
my_index = x.Map().GID(my_index);
else
my_index = x.GlobalLength();
x.Comm().MinAll(&my_index, &global_index, 1);
}
/*----------------------------------------------------------------------*
| restrict from this to next coarser level (public) m.gee 3/06|
*----------------------------------------------------------------------*/
Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::restrict_to_next_coarser_level(
Epetra_Vector* thisvec,
int current, int next)
{
Epetra_Vector* xfineP = 0;
if (current==0)
{
xfineP = new Epetra_Vector((*P_)[1]->RowMap(),false);
if (thisvec->MyLength() != xfineP->MyLength() || thisvec->GlobalLength() != xfineP->GlobalLength())
{
cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::restrict_to_next_coarser_level:\n"
<< "**ERR**: mismatch in dimension of thisvec and xfineP\n"
<< "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
}
const int mylength = thisvec->MyLength();
for (int i=0; i<mylength; i++)
(*xfineP)[i] = (*thisvec)[i];
}
else
{
xfineP = thisvec;
}
Epetra_Vector* cvec = new Epetra_Vector((*P_)[next]->OperatorDomainMap(),false);
(*P_)[next]->Multiply(true,*xfineP,*cvec);
if (current==0) delete xfineP;
return cvec;
}
/*!
* \brief Solve.
*/
void JacobiSolver::iterate( const int max_iters, const double tolerance )
{
// Extract the linear problem.
Epetra_CrsMatrix *A =
dynamic_cast<Epetra_CrsMatrix*>( d_linear_problem->GetMatrix() );
Epetra_Vector *x =
dynamic_cast<Epetra_Vector*>( d_linear_problem->GetLHS() );
const Epetra_Vector *b =
dynamic_cast<Epetra_Vector*>( d_linear_problem->GetRHS() );
// Setup the residual.
Epetra_Map row_map = A->RowMap();
Epetra_Vector residual( row_map );
// Iterate.
Epetra_CrsMatrix H = buildH( A );
Epetra_Vector temp_vec( row_map );
d_num_iters = 0;
double residual_norm = 1.0;
double b_norm;
b->NormInf( &b_norm );
double conv_crit = b_norm*tolerance;
while ( residual_norm > conv_crit && d_num_iters < max_iters )
{
H.Apply( *x, temp_vec );
x->Update( 1.0, temp_vec, 1.0, *b, 0.0 );
A->Apply( *x, temp_vec );
residual.Update( 1.0, *b, -1.0, temp_vec, 0.0 );
residual.NormInf( &residual_norm );
++d_num_iters;
}
}
/*----------------------------------------------------------------------*
| evaluate nonlinear function (public, derived) m.gee 3/06|
*----------------------------------------------------------------------*/
bool NLNML::NLNML_CoarseLevelNoxInterface::computeF(
const Epetra_Vector& x, Epetra_Vector& F,
const FillType fillFlag)
{
bool err;
if (!Level())
{
err = fineinterface_->computeF(x,F,fillFlag);
if (err==false)
{
cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::computeF:\n"
<< "**ERR**: call to fine-userinterface returned false on level " << level_ << "\n"
<< "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
}
}
else
{
RefCountPtr<Epetra_Vector> Ffine = rcp(new Epetra_Vector(fineinterface_->getGraph()->RowMap(),false));
RefCountPtr<Epetra_Vector> xfine = rcp(prolong_this_to_fine(x));
err = fineinterface_->computeF(*xfine,*Ffine,fillFlag);
if (err==false)
{
cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::computeF:\n"
<< "**ERR**: call to fine-userinterface returned false on level " << level_ << "\n"
<< "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
}
RefCountPtr<Epetra_Vector> Fcoarse = rcp(restrict_fine_to_this(*Ffine));
F.Scale(1.0,*Fcoarse);
}
if (isFAS())
F.Update(-1.0,*fxbar_,1.0,*fbar_,1.0);
return err;
}
/*----------------------------------------------------------------------*
| prolongate from this level to fine (public) m.gee 3/06|
*----------------------------------------------------------------------*/
Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::prolong_this_to_fine(
const Epetra_Vector& xcoarse)
{
if (!Level())
return new Epetra_Vector(xcoarse);
else
{
Epetra_Vector* cvec = const_cast<Epetra_Vector*>(&xcoarse);
for (int i=Level(); i>0; i--)
{
// allocate a vector matching level i-1
Epetra_Vector* fvec = wvec_[i-1].get();
// multiply
(*P_)[i]->Multiply(false,*cvec,*fvec);
cvec = fvec;
}
// Note that the GIDs in cvec do NOT match those of the fineinterface as
// they match the P_[1]->RangeMap.
// The LIDs match, so we have to copy cvec to xfine_fineinterface
// using LIDs
Epetra_Vector* xfine_fineinterface = new Epetra_Vector(fineinterface_->getGraph()->RowMap(),false);
if (cvec->MyLength() != xfine_fineinterface->MyLength() ||
cvec->GlobalLength() != xfine_fineinterface->GlobalLength())
{
cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::prolong_this_to_fine:\n"
<< "**ERR**: mismatch in dimension of cvec and xfine_fineinterface\n"
<< "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1;
}
const int mylength = cvec->MyLength();
for (int i=0; i<mylength; i++)
(*xfine_fineinterface)[i] = (*cvec)[i];
return xfine_fineinterface;
}
}
void
Albany::SolutionTwoNormResponseFunction::
evaluateGradient(const double current_time,
const Epetra_Vector* xdot,
const Epetra_Vector& x,
const Teuchos::Array<ParamVec>& p,
ParamVec* deriv_p,
Epetra_Vector* g,
Epetra_MultiVector* dg_dx,
Epetra_MultiVector* dg_dxdot,
Epetra_MultiVector* dg_dp)
{
// Evaluate response g
if (g != NULL)
x.Norm2(&(*g)[0]);
// Evaluate dg/dx
if (dg_dx != NULL) {
double nrm;
if (g != NULL)
nrm = (*g)[0];
else
x.Norm2(&nrm);
dg_dx->Scale(1.0/nrm,x);
}
// Evaluate dg/dxdot
if (dg_dxdot != NULL)
dg_dxdot->PutScalar(0.0);
// Evaluate dg/dp
if (dg_dp != NULL)
dg_dp->PutScalar(0.0);
}
// B here is the "reduced" matrix. Square matrices w/ Row=Domain=Range only.
double test_with_matvec_reduced_maps(const Epetra_CrsMatrix &A, const Epetra_CrsMatrix &B, const Epetra_Map & Bfullmap){
const Epetra_Map & Amap = A.DomainMap();
Epetra_Vector Xa(Amap), Ya(Amap), Diff(Amap);
const Epetra_Map *Bmap = Bfullmap.NumMyElements() > 0 ? &B.DomainMap() : 0;
Epetra_Vector *Xb = Bmap ? new Epetra_Vector(*Bmap) : 0;
Epetra_Vector *Yb = Bmap ? new Epetra_Vector(*Bmap) : 0;
Epetra_Vector Xb_alias(View,Bfullmap, Bmap ? Xb->Values(): 0);
Epetra_Vector Yb_alias(View,Bfullmap, Bmap ? Yb->Values(): 0);
Epetra_Import Ximport(Bfullmap,Amap);
// Set the input vector
Xa.SetSeed(24601);
Xa.Random();
Xb_alias.Import(Xa,Ximport,Insert);
// Do the multiplies
A.Apply(Xa,Ya);
if(Bmap) B.Apply(*Xb,*Yb);
// Check solution
Epetra_Import Yimport(Amap,Bfullmap);
Diff.Import(Yb_alias,Yimport,Insert);
Diff.Update(-1.0,Ya,1.0);
double norm;
Diff.Norm2(&norm);
delete Xb; delete Yb;
return norm;
}
void
Albany::SolutionAverageResponseFunction::
evaluateGradient(const double current_time,
const Epetra_Vector* xdot,
const Epetra_Vector& x,
const Teuchos::Array<ParamVec>& p,
ParamVec* deriv_p,
Epetra_Vector* g,
Epetra_MultiVector* dg_dx,
Epetra_MultiVector* dg_dxdot,
Epetra_MultiVector* dg_dp)
{
// Evaluate response g
if (g != NULL)
x.MeanValue(&(*g)[0]);
// Evaluate dg/dx
if (dg_dx != NULL)
dg_dx->PutScalar(1.0 / x.GlobalLength());
// Evaluate dg/dxdot
if (dg_dxdot != NULL)
dg_dxdot->PutScalar(0.0);
// Evaluate dg/dp
if (dg_dp != NULL)
dg_dp->PutScalar(0.0);
}
void
Albany::SolutionAverageResponseFunction::
evaluateTangent(const double alpha,
const double beta,
const double current_time,
bool sum_derivs,
const Epetra_Vector* xdot,
const Epetra_Vector& x,
const Teuchos::Array<ParamVec>& p,
ParamVec* deriv_p,
const Epetra_MultiVector* Vxdot,
const Epetra_MultiVector* Vx,
const Epetra_MultiVector* Vp,
Epetra_Vector* g,
Epetra_MultiVector* gx,
Epetra_MultiVector* gp)
{
// Evaluate response g
if (g != NULL)
x.MeanValue(&(*g)[0]);
// Evaluate tangent of g = dg/dx*Vx + dg/dxdot*Vxdot + dg/dp*Vp
// If Vx == NULL, Vx is the identity
if (gx != NULL) {
if (Vx != NULL)
for (int j=0; j<Vx->NumVectors(); j++)
(*Vx)(j)->MeanValue(&(*gx)[j][0]);
else
gx->PutScalar(1.0/x.GlobalLength());
gx->Scale(alpha);
}
if (gp != NULL)
gp->PutScalar(0.0);
}
double AztecOO_StatusTestResNorm::ComputeNorm(const Epetra_Vector & vec, NormType typeofnorm) {
double result = 0.0;
if (typeofnorm==TwoNorm) vec.Norm2(&result);
else if (typeofnorm==OneNorm) vec.Norm1(&result);
else vec.NormInf(&result);
return(result);
}
EpetraVector<Scalar>::EpetraVector(const Epetra_Vector &v)
{
this->vec = (Epetra_Vector *)&v;
this->vec_im = nullptr;
this->std_map = (Epetra_BlockMap *)&v.Map();
this->size = v.MyLength();
this->owner = false;
}
//----------------------------------------------------------------------------
//
// Transfer solution between meshes.
//
void
AAdapt::CopyRemesh::
solutionTransfer(const Epetra_Vector& oldSolution,
Epetra_Vector& newSolution) {
TEUCHOS_TEST_FOR_EXCEPT(oldSolution.MyLength() != newSolution.MyLength());
newSolution = oldSolution;
}
void observeSolution(
const Epetra_Vector& solution, double time_or_param_val)
{
double norm; solution.Norm2(&norm);
if (solution.Comm().MyPID()==0)
std::cout << "ObserveSolution: Norm = " << norm
<< " for param/time = " << time_or_param_val << std::endl;
}
Epetra_CrsMatrix *
NOX::Epetra::DebugTools::compute_matrix_using_operator( const Epetra_Operator * op)
{
const Epetra_Map & rowMap = op->OperatorDomainMap();
Epetra_CrsMatrix * p_mat = new Epetra_CrsMatrix(Copy, rowMap, 0);
Epetra_Vector * tempVec = new Epetra_Vector(rowMap);
Epetra_Vector * tempRes = new Epetra_Vector(rowMap);
// Show progress on what could be a long operation
if( 0 == op->Comm().MyPID() )
{
std::cout << "**************** CREATING MATRIX FROM OPERATOR ************************ "
<< std::endl;
std::cout << NOX::Utils::fill(72) << std::endl;
}
int totalPerturbations = tempVec->GlobalLength();
int outFreq = totalPerturbations / 71;
if( 1 > outFreq )
outFreq = 1;
for( int col = 0; col < tempVec->GlobalLength(); ++col )
{
tempVec->PutScalar(0.0);
if( rowMap.MyGID(col) )
(*tempVec)[col] = 1.0;
op->Apply(*tempVec, *tempRes);
// Fill in only the nonzero entries from the apply
for( int row = 0; row < p_mat->NumMyRows(); ++row)
{
if( fabs( (*tempRes)[row] ) > 1.e-12 )
{
int ierr = p_mat->InsertGlobalValues( rowMap.GID(row), 1, &(*tempRes)[row], &col );
if( ierr < 0 )
{
std::string msg = //"ERROR (" + ierr + ") : "
"NOX::Epetra::DebugTools::compute_matrix_using_operator crsMatrix.ExtractGlobalRowView(...) failed for row : ";// + row;
throw msg;
}
}
}
if( (0 == op->Comm().MyPID()) && (0 == (col % outFreq)) )
std::cout << "-" << std::flush;
}
if( 0 == op->Comm().MyPID() )
std::cout << "*" << std::endl;
p_mat->FillComplete();
delete tempRes;
delete tempVec;
return p_mat;
}
//EpetraVector_To_TpetraVectorNonConst: copies Epetra_Vector to non-const Tpetra_Vector
Teuchos::RCP<Tpetra_Vector> Petra::EpetraVector_To_TpetraVectorNonConst(const Epetra_Vector& epetraVector_,
const Teuchos::RCP<const Teuchos::Comm<int> >& commT_)
{
//get map from epetraVector_ and convert to Tpetra::Map
auto mapT = EpetraMap_To_TpetraMap(epetraVector_.Map(), commT_);
ST *values;
epetraVector_.ExtractView(&values);
Teuchos::ArrayView<ST> valuesAV = Teuchos::arrayView(values, mapT->getNodeNumElements());
Teuchos::RCP<Tpetra_Vector> tpetraVector_ = Teuchos::rcp(new Tpetra_Vector(mapT, valuesAV));
return tpetraVector_;
}
void EpetraLinearOp::computeAbsRowSum(Epetra_Vector & x) const
{
TEUCHOS_ASSERT(!is_null(rowMatrix_));
RCP<Epetra_CrsMatrix> crsMatrix
= Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(rowMatrix_);
TEUCHOS_TEST_FOR_EXCEPTION(is_null(crsMatrix),
Exceptions::OpNotSupported,
"EpetraLinearOp::computeAbsRowSum(...): wrapped matrix must be of type "
"Epetra_CrsMatrix for this method. Other operator types are not supported."
);
//
// Put inverse of the sum of absolute values of the ith row of A in x[i].
// (this is a modified copy of Epetra_CrsMatrix::InvRowSums)
//
if (crsMatrix->Filled()) {
TEUCHOS_TEST_FOR_EXCEPTION(is_null(crsMatrix),
std::invalid_argument,
"EpetraLinearOp::computeAbsRowSum(...): Epetra_CrsMatrix must be filled"
);
}
int i, j;
x.PutScalar(0.0); // Make sure we sum into a vector of zeros.
double * xp = (double*)x.Values();
if (crsMatrix->Graph().RangeMap().SameAs(x.Map()) && crsMatrix->Exporter() != 0) {
Epetra_Vector x_tmp(crsMatrix->RowMap());
x_tmp.PutScalar(0.0);
double * x_tmp_p = (double*)x_tmp.Values();
for (i=0; i < crsMatrix->NumMyRows(); i++) {
int NumEntries = 0;
double * RowValues = 0;
crsMatrix->ExtractMyRowView(i,NumEntries,RowValues);
for (j=0; j < NumEntries; j++) x_tmp_p[i] += std::abs(RowValues[j]);
}
TEUCHOS_TEST_FOR_EXCEPT(0!=x.Export(x_tmp, *crsMatrix->Exporter(), Add)); //Export partial row sums to x.
}
else if (crsMatrix->Graph().RowMap().SameAs(x.Map())) {
for (i=0; i < crsMatrix->NumMyRows(); i++) {
int NumEntries = 0;
double * RowValues = 0;
crsMatrix->ExtractMyRowView(i,NumEntries,RowValues);
double scale = 0.0;
for (j=0; j < NumEntries; j++) scale += std::abs(RowValues[j]);
xp[i] = scale;
}
}
else { // x.Map different than both crsMatrix->Graph().RowMap() and crsMatrix->Graph().RangeMap()
TEUCHOS_TEST_FOR_EXCEPT(true); // The map of x must be the RowMap or RangeMap of A.
}
}
void NOX::Epetra::Scaling::computeScaling(const Epetra_LinearProblem& problem)
{
Epetra_Vector* diagonal = 0;
for (unsigned int i = 0; i < scaleVector.size(); i ++) {
if (sourceType[i] == RowSum) {
diagonal = scaleVector[i].get();
// Make sure the Jacobian is an Epetra_RowMatrix, otherwise we can't
// perform a row sum scale!
const Epetra_RowMatrix* test = 0;
test = dynamic_cast<const Epetra_RowMatrix*>(problem.GetOperator());
if (test == 0) {
std::cout << "ERROR: NOX::Epetra::Scaling::scaleLinearSystem() - "
<< "For \"Row Sum\" scaling, the Matrix must be an "
<< "Epetra_RowMatrix derived object!" << std::endl;
throw "NOX Error";
}
test->InvRowSums(*diagonal);
diagonal->Reciprocal(*diagonal);
}
else if (sourceType[i] == ColSum) {
diagonal = scaleVector[i].get();
// Make sure the Jacobian is an Epetra_RowMatrix, otherwise we can't
// perform a row sum scale!
const Epetra_RowMatrix* test = 0;
test = dynamic_cast<const Epetra_RowMatrix*>(problem.GetOperator());
if (test == 0) {
std::cout << "ERROR: NOX::Epetra::Scaling::scaleLinearSystem() - "
<< "For \"Column Sum\" scaling, the Matrix must be an "
<< "Epetra_RowMatrix derived object!" << std::endl;
throw "NOX Error";
}
test->InvColSums(*diagonal);
diagonal->Reciprocal(*diagonal);
}
}
}
void EpetraExt::scaleModelVarsGivenInverseScaling(
const Epetra_Vector &origVars,
const Epetra_Vector &invVarScaling,
Epetra_Vector *scaledVars
)
{
#ifdef TEUCHOS_DEBUG
TEUCHOS_TEST_FOR_EXCEPT(!scaledVars);
TEUCHOS_TEST_FOR_EXCEPT(!origVars.Map().SameAs(invVarScaling.Map()));
TEUCHOS_TEST_FOR_EXCEPT(!origVars.Map().SameAs(scaledVars->Map()));
#endif
const int localDim = origVars.Map().NumMyElements();
for ( int i = 0; i < localDim; ++i )
(*scaledVars)[i] = origVars[i] / invVarScaling[i];
}
//=============================================================================
//=============================================================================
int Epetra_MsrMatrix::InvColSums(Epetra_Vector& x) const {
//
// Put inverse of the sum of absolute values of the jth column of A in x[j].
//
if (!Filled()) EPETRA_CHK_ERR(-1); // Matrix must be filled.
if (!OperatorDomainMap().SameAs(x.Map())) EPETRA_CHK_ERR(-2); // x must have the same distribution as the domain of A
Epetra_Vector * xp = 0;
Epetra_Vector * x_tmp = 0;
// If we have a non-trivial importer, we must export elements that are permuted or belong to other processors
if (RowMatrixImporter()!=0) {
x_tmp = new Epetra_Vector(RowMatrixColMap()); // Create import vector if needed
xp = x_tmp;
}
int ierr = 0;
int i, j;
for (i=0; i < NumMyCols_; i++) (*xp)[i] = 0.0;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = GetRow(i);// Copies ith row of matrix into Values_ and Indices_
for (j=0; j < NumEntries; j++) (*xp)[Indices_[j]] += fabs(Values_[j]);
}
if (RowMatrixImporter()!=0){
x.Export(*x_tmp, *RowMatrixImporter(), Add); // Fill x with Values from import vector
delete x_tmp;
xp = &x;
}
// Invert values, don't allow them to get too large
for (i=0; i < NumMyRows_; i++) {
double scale = (*xp)[i];
if (scale<Epetra_MinDouble) {
if (scale==0.0) ierr = 1; // Set error to 1 to signal that zero rowsum found (supercedes ierr = 2)
else if (ierr!=1) ierr = 2;
(*xp)[i] = Epetra_MaxDouble;
}
else
(*xp)[i] = 1.0/scale;
}
UpdateFlops(NumGlobalNonzeros());
EPETRA_CHK_ERR(ierr);
return(0);
}
// *****************************************************************
// *****************************************************************
void LOCA::Epetra::ModelEvaluatorInterface::
setXdot(const Epetra_Vector& xdot_, const double time_)
{
if (x_dot == NULL)
x_dot = new Epetra_Vector(xdot_.Map());
*x_dot = xdot_;
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeShiftedMatrix(double alpha, double beta, const Epetra_Vector& x,
Epetra_Operator& A)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(-beta); // alpha and beta are switched between LOCA and Thyra
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(alpha);
alpha_prev = -beta; beta_prev = alpha; // prec must know alpha and beta
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(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
outargs.set_f(eval_f);
outargs.set_W(Teuchos::rcp(&A, false));
model_->evalModel(inargs, outargs);
return true;
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeJacobian(const Epetra_Vector& x, Epetra_Operator& Jac)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&x, false));
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(0.0);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(1.0);
alpha_prev = 0.0; beta_prev = 1.0; // prec must know alpha and beta
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(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
outargs.set_f(eval_f);
outargs.set_W(Teuchos::rcp(&Jac, false));
model_->evalModel(inargs, outargs);
return true;
}
// *****************************************************************
// *****************************************************************
bool LOCA::Epetra::ModelEvaluatorInterface::
computeF(const Epetra_Vector& x, Epetra_Vector& F, const FillType fillFlag)
{
// Create inargs
EpetraExt::ModelEvaluator::InArgs inargs = model_->createInArgs();
inargs.set_x(Teuchos::rcp(&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(x.Map());
inargs.set_x_dot(Teuchos::rcp(x_dot, false));
}
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_alpha))
inargs.set_alpha(0.0);
if (inargs.supports(EpetraExt::ModelEvaluator::IN_ARG_beta))
inargs.set_beta(1.0);
// Create outargs
EpetraExt::ModelEvaluator::OutArgs outargs = model_->createOutArgs();
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> eval_f;
Teuchos::RefCountPtr<Epetra_Vector> f = Teuchos::rcp(&F, false);
if (fillFlag == NOX::Epetra::Interface::Required::Residual)
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_EXACT);
else if (fillFlag == NOX::Epetra::Interface::Required::Jac)
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_APPROX_DERIV);
else
eval_f.reset(f, EpetraExt::ModelEvaluator::EVAL_TYPE_VERY_APPROX_DERIV);
outargs.set_f(eval_f);
model_->evalModel(inargs, outargs);
return true;
}
void scatter_to_vector(const std::string & blockId, const panzer::DOFManagerFEI<int,int> & dofMngr,
const std::map<std::string,Kokkos::DynRankView<double,PHX::Device> > & fc,
const std::vector<std::size_t> & localCellIds,
Epetra_Vector & x)
{
std::map<std::string,Kokkos::DynRankView<double,PHX::Device> >::const_iterator fieldItr;
for(fieldItr=fc.begin();fieldItr!=fc.end();++fieldItr) {
std::string fieldStr = fieldItr->first;
int fieldNum = dofMngr.getFieldNum(fieldStr);
const Kokkos::DynRankView<double,PHX::Device> & data = fieldItr->second;
// gather operation for each cell in workset
for(std::size_t worksetCellIndex=0;worksetCellIndex<localCellIds.size();++worksetCellIndex) {
std::vector<int> GIDs, LIDs;
std::size_t cellLocalId = localCellIds[worksetCellIndex];
dofMngr.getElementGIDs(cellLocalId,GIDs);
// caculate the local IDs for this element
LIDs.resize(GIDs.size());
for(std::size_t i=0;i<GIDs.size();i++)
LIDs[i] = x.Map().LID(GIDs[i]);
const std::vector<int> & elmtOffset = dofMngr.getGIDFieldOffsets(blockId,fieldNum);
// loop over basis functions and fill the fields
for(int basis=0;basis<data.dimension(1);basis++) {
int offset = elmtOffset[basis];
int lid = LIDs[offset];
x[lid] = data(worksetCellIndex,basis);
}
}
}
}
//=============================================================================
int Epetra_MsrMatrix::LeftScale(const Epetra_Vector& x) {
//
// This function scales the ith row of A by x[i].
//
// For this method, we have no choice but to work with the UGLY MSR data structures.
if (!Filled()) EPETRA_CHK_ERR(-1); // Matrix must be filled.
if (!OperatorRangeMap().SameAs(x.Map())) EPETRA_CHK_ERR(-2); // x must have the same distribution as the range of A
int i, j;
int * bindx = Amat_->bindx;
double * val = Amat_->val;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = bindx[i+1] - bindx[i];
double scale = x[i];
val[i] *= scale;
double * Values = val + bindx[i];
for (j=0; j < NumEntries; j++) Values[j] *= scale;
}
NormOne_ = -1.0; // Reset Norm so it will be recomputed.
NormInf_ = -1.0; // Reset Norm so it will be recomputed.
UpdateFlops(NumGlobalNonzeros());
return(0);
}
//=============================================================================
int Epetra_MsrMatrix::InvRowSums(Epetra_Vector& x) const {
//
// Put inverse of the sum of absolute values of the ith row of A in x[i].
//
if (!OperatorRangeMap().SameAs(x.Map())) EPETRA_CHK_ERR(-2); // x must have the same distribution as the range of A
int ierr = 0;
int i, j;
for (i=0; i < NumMyRows_; i++) {
int NumEntries = GetRow(i); // Copies ith row of matrix into Values_ and Indices_
double scale = 0.0;
for (j=0; j < NumEntries; j++) scale += fabs(Values_[j]);
if (scale<Epetra_MinDouble) {
if (scale==0.0) ierr = 1; // Set error to 1 to signal that zero rowsum found (supercedes ierr = 2)
else if (ierr!=1) ierr = 2;
x[i] = Epetra_MaxDouble;
}
else
x[i] = 1.0/scale;
}
UpdateFlops(NumGlobalNonzeros());
EPETRA_CHK_ERR(ierr);
return(0);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void printVector(std::string filename_prefix, const Epetra_Vector& vector,
int newton_step)
{
std::stringstream ss;
ss << filename_prefix << "_" << newton_step << ".dat";
ofstream file( ss.str().c_str(), ios::out | ios::app );
vector.Print(file);
}
