libMesh::Problem_Interface Class Reference

Inheritance diagram for libMesh::Problem_Interface:

Public Member Functions
	Problem_Interface (NoxNonlinearSolver< Number > *solver)
	~Problem_Interface ()
bool	computeF (const Epetra_Vector &x, Epetra_Vector &FVec, NOX::Epetra::Interface::Required::FillType fillType)
	Compute and return F.
bool	computeJacobian (const Epetra_Vector &x, Epetra_Operator &Jac)
	Compute an explicit Jacobian.
bool	computePrecMatrix (const Epetra_Vector &x, Epetra_RowMatrix &M)
	Compute the Epetra_RowMatrix M, that will be used by the Aztec preconditioner instead of the Jacobian.
bool	computePreconditioner (const Epetra_Vector &x, Epetra_Operator &Prec, Teuchos::ParameterList *p)
	Computes a user supplied preconditioner based on input vector x.

Public Attributes
NoxNonlinearSolver< Number > *	_solver

Detailed Description

Definition at line 45 of file trilinos_nox_nonlinear_solver.C.

Constructor & Destructor Documentation

Problem_Interface()

libMesh::Problem_Interface::Problem_Interface ( NoxNonlinearSolver< Number > *  solver )

explicit

Definition at line 84 of file trilinos_nox_nonlinear_solver.C.

                                                                        :
  _solver(solver)
{}

~Problem_Interface()

libMesh::Problem_Interface::~Problem_Interface ( )

default

Member Function Documentation

computeF()

bool libMesh::Problem_Interface::computeF	(	const Epetra_Vector &	x,
		Epetra_Vector &	FVec,
		NOX::Epetra::Interface::Required::FillType	fillType
	)

Compute and return F.

Definition at line 94 of file trilinos_nox_nonlinear_solver.C.

{
  LOG_SCOPE("residual()", "TrilinosNoxNonlinearSolver");
 
  NonlinearImplicitSystem & sys = _solver->system();
 
  EpetraVector<Number> X_global(*const_cast<Epetra_Vector *>(&x), sys.comm()), R(r, sys.comm());
  EpetraVector<Number> & X_sys = *cast_ptr<EpetraVector<Number> *>(sys.solution.get());
  EpetraVector<Number> & R_sys = *cast_ptr<EpetraVector<Number> *>(sys.rhs);
 
  // Use the systems update() to get a good local version of the parallel solution
  X_global.swap(X_sys);
  R.swap(R_sys);
 
  if (_solver->_exact_constraint_enforcement)
    sys.get_dof_map().enforce_constraints_exactly(sys);
  sys.update();
 
  // Swap back
  X_global.swap(X_sys);
  R.swap(R_sys);
 
  R.zero();
 
  //-----------------------------------------------------------------------------
  // if the user has provided both function pointers and objects only the pointer
  // will be used, so catch that as an error
 
  libmesh_error_msg_if(_solver->residual && _solver->residual_object, "ERROR: cannot specify both a function and object to compute the Residual!");
 
  libmesh_error_msg_if(_solver->matvec && _solver->residual_and_jacobian_object,
                       "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
 
  if (_solver->residual != nullptr)
    _solver->residual(*sys.current_local_solution.get(), R, sys);
 
  else if (_solver->residual_object != nullptr)
    _solver->residual_object->residual(*sys.current_local_solution.get(), R, sys);
 
  else if (_solver->matvec != nullptr)
    _solver->matvec(*sys.current_local_solution.get(), &R, nullptr, sys);
 
  else if (_solver->residual_and_jacobian_object != nullptr)
    _solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), &R, nullptr, sys);
 
  else
    return false;
 
  R.close();
  X_global.close();
 
  return true;
}

computeJacobian()

bool libMesh::Problem_Interface::computeJacobian	(	const Epetra_Vector &	x,
		Epetra_Operator &	Jac
	)

Compute an explicit Jacobian.

Definition at line 152 of file trilinos_nox_nonlinear_solver.C.

{
  LOG_SCOPE("jacobian()", "TrilinosNoxNonlinearSolver");
 
  NonlinearImplicitSystem & sys = _solver->system();
 
  EpetraMatrix<Number> J(&dynamic_cast<Epetra_FECrsMatrix &>(jac), sys.comm());
  EpetraVector<Number> & X_sys = *cast_ptr<EpetraVector<Number> *>(sys.solution.get());
  EpetraVector<Number> X_global(*const_cast<Epetra_Vector *>(&x), sys.comm());
 
  // Set the dof maps
  J.attach_dof_map(sys.get_dof_map());
 
  // Use the systems update() to get a good local version of the parallel solution
  X_global.swap(X_sys);
 
  if (_solver->_exact_constraint_enforcement)
    sys.get_dof_map().enforce_constraints_exactly(sys);
  sys.update();
 
  X_global.swap(X_sys);
 
  //-----------------------------------------------------------------------------
  // if the user has provided both function pointers and objects only the pointer
  // will be used, so catch that as an error
  libmesh_error_msg_if(_solver->jacobian && _solver->jacobian_object,
                       "ERROR: cannot specify both a function and object to compute the Jacobian!");
 
  libmesh_error_msg_if(_solver->matvec && _solver->residual_and_jacobian_object,
                       "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
 
  if (_solver->jacobian != nullptr)
    _solver->jacobian(*sys.current_local_solution.get(), J, sys);
 
  else if (_solver->jacobian_object != nullptr)
    _solver->jacobian_object->jacobian(*sys.current_local_solution.get(), J, sys);
 
  else if (_solver->matvec != nullptr)
    _solver->matvec(*sys.current_local_solution.get(), nullptr, &J, sys);
 
  else if (_solver->residual_and_jacobian_object != nullptr)
    _solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), nullptr, &J, sys);
 
  else
    libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
 
  J.close();
  X_global.close();
 
  return true;
}

References libMesh::NonlinearSolver< T >::_exact_constraint_enforcement, _solver, libMesh::SparseMatrix< T >::attach_dof_map(), libMesh::EpetraMatrix< T >::close(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libMesh::NonlinearImplicitSystem::ComputeJacobian::jacobian(), libMesh::NonlinearSolver< T >::jacobian, libMesh::NonlinearSolver< T >::jacobian_object, libMesh::NonlinearSolver< T >::matvec, libMesh::NonlinearImplicitSystem::ComputeResidualandJacobian::residual_and_jacobian(), libMesh::NonlinearSolver< T >::residual_and_jacobian_object, libMesh::System::solution, libMesh::NonlinearSolver< T >::system(), and libMesh::System::update().

computePrecMatrix()

bool libMesh::Problem_Interface::computePrecMatrix	(	const Epetra_Vector &	x,
		Epetra_RowMatrix &	M
	)

Compute the Epetra_RowMatrix M, that will be used by the Aztec preconditioner instead of the Jacobian.

This is used when there is no explicit Jacobian present (i.e. Matrix-Free Newton-Krylov). This MUST BE an Epetra_RowMatrix since the Aztec preconditioners need to know the sparsity pattern of the matrix. Returns true if computation was successful.

Definition at line 207 of file trilinos_nox_nonlinear_solver.C.

{
  //   libMesh::out << "ERROR: Problem_Interface::preconditionVector() - Use Explicit Jacobian only for this test problem!" << endl;
  throw 1;
}

computePreconditioner()

bool libMesh::Problem_Interface::computePreconditioner	(	const Epetra_Vector &	x,
		Epetra_Operator &	Prec,
		Teuchos::ParameterList *	p
	)

Computes a user supplied preconditioner based on input vector x.

Returns true if computation was successful.

Definition at line 215 of file trilinos_nox_nonlinear_solver.C.

{
  LOG_SCOPE("preconditioner()", "TrilinosNoxNonlinearSolver");
 
  NonlinearImplicitSystem & sys = _solver->system();
  TrilinosPreconditioner<Number> & tpc = dynamic_cast<TrilinosPreconditioner<Number> &>(prec);
 
  EpetraMatrix<Number> J(dynamic_cast<Epetra_FECrsMatrix *>(tpc.mat()),sys.comm());
  EpetraVector<Number> & X_sys = *cast_ptr<EpetraVector<Number> *>(sys.solution.get());
  EpetraVector<Number> X_global(*const_cast<Epetra_Vector *>(&x), sys.comm());
 
  // Set the dof maps
  J.attach_dof_map(sys.get_dof_map());
 
  // Use the systems update() to get a good local version of the parallel solution
  X_global.swap(X_sys);
 
  if (this->_exact_constraint_enforcement)
    sys.get_dof_map().enforce_constraints_exactly(sys);
  sys.update();
 
  X_global.swap(X_sys);
 
  //-----------------------------------------------------------------------------
  // if the user has provided both function pointers and objects only the pointer
  // will be used, so catch that as an error
  libmesh_error_msg_if(_solver->jacobian && _solver->jacobian_object,
                       "ERROR: cannot specify both a function and object to compute the Jacobian!");
 
  libmesh_error_msg_if(_solver->matvec && _solver->residual_and_jacobian_object,
                       "ERROR: cannot specify both a function and object to compute the combined Residual & Jacobian!");
 
  if (_solver->jacobian != nullptr)
    _solver->jacobian(*sys.current_local_solution.get(), J, sys);
 
  else if (_solver->jacobian_object != nullptr)
    _solver->jacobian_object->jacobian(*sys.current_local_solution.get(), J, sys);
 
  else if (_solver->matvec != nullptr)
    _solver->matvec(*sys.current_local_solution.get(), nullptr, &J, sys);
 
  else if (_solver->residual_and_jacobian_object != nullptr)
    _solver->residual_and_jacobian_object->residual_and_jacobian (*sys.current_local_solution.get(), nullptr, &J, sys);
 
  else
    libmesh_error_msg("Error! Unable to compute residual and/or Jacobian!");
 
  J.close();
  X_global.close();
 
  tpc.compute();
 
  return true;
}

References _solver, libMesh::ParallelObject::comm(), libMesh::TrilinosPreconditioner< T >::compute(), libMesh::System::current_local_solution, libMesh::DofMap::enforce_constraints_exactly(), libMesh::System::get_dof_map(), libMesh::NonlinearImplicitSystem::ComputeJacobian::jacobian(), libMesh::NonlinearSolver< T >::jacobian, libMesh::NonlinearSolver< T >::jacobian_object, libMesh::TrilinosPreconditioner< T >::mat(), libMesh::NonlinearSolver< T >::matvec, libMesh::NonlinearImplicitSystem::ComputeResidualandJacobian::residual_and_jacobian(), libMesh::NonlinearSolver< T >::residual_and_jacobian_object, libMesh::System::solution, libMesh::NonlinearSolver< T >::system(), and libMesh::System::update().

Member Data Documentation

_solver

NoxNonlinearSolver<Number>* libMesh::Problem_Interface::_solver

Definition at line 79 of file trilinos_nox_nonlinear_solver.C.

Referenced by computeJacobian(), computePreconditioner(), and libMesh::NoxNonlinearSolver< Number >::solve().

---

The documentation for this class was generated from the following file:

• src/solvers/trilinos_nox_nonlinear_solver.C