void PetscMatrix<T>::add_block_matrix(const DenseMatrix<T>& dm,
const std::vector<numeric_index_type>& brows,
const std::vector<numeric_index_type>& bcols)
{
libmesh_assert (this->initialized());
const numeric_index_type n_rows = dm.m();
const numeric_index_type n_cols = dm.n();
const numeric_index_type n_brows = brows.size();
const numeric_index_type n_bcols = bcols.size();
const numeric_index_type blocksize = n_rows / n_brows;
libmesh_assert_equal_to (n_cols / n_bcols, blocksize);
libmesh_assert_equal_to (blocksize*n_brows, n_rows);
libmesh_assert_equal_to (blocksize*n_bcols, n_cols);
PetscErrorCode ierr=0;
#ifndef NDEBUG
PetscInt petsc_blocksize;
ierr = MatGetBlockSize(_mat, &petsc_blocksize);
LIBMESH_CHKERRABORT(ierr);
libmesh_assert_equal_to (blocksize, static_cast<numeric_index_type>(petsc_blocksize));
#endif
// These casts are required for PETSc <= 2.1.5
ierr = MatSetValuesBlocked(_mat,
n_brows, (PetscInt*) &brows[0],
n_bcols, (PetscInt*) &bcols[0],
(PetscScalar*) &dm.get_values()[0],
ADD_VALUES);
LIBMESH_CHKERRABORT(ierr);
}
std::pair<unsigned int, unsigned int>
SlepcEigenSolver<T>::solve_standard (ShellMatrix<T> &shell_matrix,
int nev, // number of requested eigenpairs
int ncv, // number of basis vectors
const double tol, // solver tolerance
const unsigned int m_its) // maximum number of iterations
{
this->init ();
int ierr=0;
// Prepare the matrix.
Mat mat;
ierr = MatCreateShell(this->comm().get(),
shell_matrix.m(), // Specify the number of local rows
shell_matrix.n(), // Specify the number of local columns
PETSC_DETERMINE,
PETSC_DETERMINE,
const_cast<void*>(static_cast<const void*>(&shell_matrix)),
&mat);
/* Note that the const_cast above is only necessary because PETSc
does not accept a const void*. Inside the member function
_petsc_shell_matrix() below, the pointer is casted back to a
const ShellMatrix<T>*. */
LIBMESH_CHKERRABORT(ierr);
ierr = MatShellSetOperation(mat,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
ierr = MatShellSetOperation(mat,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
LIBMESH_CHKERRABORT(ierr);
return _solve_standard_helper(mat, nev, ncv, tol, m_its);
}
void PetscMatrix<T>::get_transpose (SparseMatrix<T>& dest) const
{
// Make sure the SparseMatrix passed in is really a PetscMatrix
PetscMatrix<T>& petsc_dest = libmesh_cast_ref<PetscMatrix<T>&>(dest);
// If we aren't reusing the matrix then need to clear dest,
// otherwise we get a memory leak
if(&petsc_dest != this)
dest.clear();
PetscErrorCode ierr;
#if PETSC_VERSION_LESS_THAN(3,0,0)
if (&petsc_dest == this)
ierr = MatTranspose(_mat,PETSC_NULL);
else
ierr = MatTranspose(_mat,&petsc_dest._mat);
LIBMESH_CHKERRABORT(ierr);
#else
// FIXME - we can probably use MAT_REUSE_MATRIX in more situations
if (&petsc_dest == this)
ierr = MatTranspose(_mat,MAT_REUSE_MATRIX,&petsc_dest._mat);
else
ierr = MatTranspose(_mat,MAT_INITIAL_MATRIX,&petsc_dest._mat);
LIBMESH_CHKERRABORT(ierr);
#endif
// Specify that the transposed matrix is initialized and close it.
petsc_dest._is_initialized = true;
petsc_dest.close();
}
void PetscDiffSolver::init ()
{
START_LOG("init()", "PetscDiffSolver");
Parent::init();
int ierr=0;
#if PETSC_VERSION_LESS_THAN(2,1,2)
// At least until Petsc 2.1.1, the SNESCreate had a different
// calling syntax. The second argument was of type SNESProblemType,
// and could have a value of either SNES_NONLINEAR_EQUATIONS or
// SNES_UNCONSTRAINED_MINIMIZATION.
ierr = SNESCreate(this->comm().get(), SNES_NONLINEAR_EQUATIONS, &_snes);
LIBMESH_CHKERRABORT(ierr);
#else
ierr = SNESCreate(this->comm().get(),&_snes);
LIBMESH_CHKERRABORT(ierr);
#endif
#if PETSC_VERSION_LESS_THAN(2,3,3)
ierr = SNESSetMonitor (_snes, __libmesh_petsc_diff_solver_monitor,
this, PETSC_NULL);
#else
// API name change in PETSc 2.3.3
ierr = SNESMonitorSet (_snes, __libmesh_petsc_diff_solver_monitor,
this, PETSC_NULL);
#endif
LIBMESH_CHKERRABORT(ierr);
ierr = SNESSetFromOptions(_snes);
LIBMESH_CHKERRABORT(ierr);
STOP_LOG("init()", "PetscDiffSolver");
}
unsigned int PetscDiffSolver::solve()
{
this->init();
START_LOG("solve()", "PetscDiffSolver");
PetscVector<Number> &x =
*(libmesh_cast_ptr<PetscVector<Number>*>(_system.solution.get()));
PetscMatrix<Number> &jac =
*(libmesh_cast_ptr<PetscMatrix<Number>*>(_system.matrix));
PetscVector<Number> &r =
*(libmesh_cast_ptr<PetscVector<Number>*>(_system.rhs));
#ifdef LIBMESH_ENABLE_CONSTRAINTS
_system.get_dof_map().enforce_constraints_exactly(_system);
#endif
int ierr = 0;
ierr = SNESSetFunction (_snes, r.vec(),
__libmesh_petsc_diff_solver_residual, this);
LIBMESH_CHKERRABORT(ierr);
ierr = SNESSetJacobian (_snes, jac.mat(), jac.mat(),
__libmesh_petsc_diff_solver_jacobian, this);
LIBMESH_CHKERRABORT(ierr);
# if PETSC_VERSION_LESS_THAN(2,2,0)
ierr = SNESSolve (_snes, x.vec(), &_outer_iterations);
LIBMESH_CHKERRABORT(ierr);
// 2.2.x style
#elif PETSC_VERSION_LESS_THAN(2,3,0)
ierr = SNESSolve (_snes, x.vec());
LIBMESH_CHKERRABORT(ierr);
// 2.3.x & newer style
#else
ierr = SNESSolve (_snes, PETSC_NULL, x.vec());
LIBMESH_CHKERRABORT(ierr);
#endif
STOP_LOG("solve()", "PetscDiffSolver");
SNESConvergedReason reason;
SNESGetConvergedReason(_snes, &reason);
this->clear();
return convert_solve_result(reason);
}
std::pair<unsigned int, Real>
PetscDMNonlinearSolver<T>::solve (SparseMatrix<T>& jac_in, // System Jacobian Matrix
NumericVector<T>& x_in, // Solution vector
NumericVector<T>& r_in, // Residual vector
const double, // Stopping tolerance
const unsigned int)
{
START_LOG("solve()", "PetscNonlinearSolver");
this->init ();
// Make sure the data passed in are really of Petsc types
libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
libmesh_cast_ptr<PetscVector<T>*>(&r_in);
// Extract solution vector
PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
PetscErrorCode ierr=0;
PetscInt n_iterations =0;
PetscReal final_residual_norm=0.;
if (this->user_presolve)
this->user_presolve(this->system());
//Set the preconditioning matrix
if (this->_preconditioner)
this->_preconditioner->set_matrix(jac_in);
ierr = SNESSolve (this->_snes, PETSC_NULL, x->vec());
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetIterationNumber(this->_snes,&n_iterations);
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetLinearSolveIterations(this->_snes, &this->_n_linear_iterations);
LIBMESH_CHKERRABORT(ierr);
ierr = SNESGetFunctionNorm(this->_snes,&final_residual_norm);
LIBMESH_CHKERRABORT(ierr);
// Get and store the reason for convergence
SNESGetConvergedReason(this->_snes, &this->_reason);
//Based on Petsc 2.3.3 documentation all diverged reasons are negative
this->converged = (this->_reason >= 0);
this->clear();
STOP_LOG("solve()", "PetscNonlinearSolver");
// return the # of its. and the final residual norm.
return std::make_pair(n_iterations, final_residual_norm);
}
void PetscMatrix<T>::zero_rows (std::vector<numeric_index_type> & rows, T diag_value)
{
libmesh_assert (this->initialized());
semiparallel_only();
PetscErrorCode ierr=0;
#if PETSC_VERSION_RELEASE && PETSC_VERSION_LESS_THAN(3,1,1)
if(!rows.empty())
ierr = MatZeroRows(_mat, rows.size(), (PetscInt*)&rows[0], diag_value);
else
ierr = MatZeroRows(_mat, 0, PETSC_NULL, diag_value);
#else
// As of petsc-dev at the time of 3.1.0, MatZeroRows now takes two additional
// optional arguments. The optional arguments (x,b) can be used to specify the
// solutions for the zeroed rows (x) and right hand side (b) to update.
// Could be useful for setting boundary conditions...
if(!rows.empty())
ierr = MatZeroRows(_mat, rows.size(), (PetscInt*)&rows[0], diag_value, PETSC_NULL, PETSC_NULL);
else
ierr = MatZeroRows(_mat, 0, PETSC_NULL, diag_value, PETSC_NULL, PETSC_NULL);
#endif
LIBMESH_CHKERRABORT(ierr);
}
std::pair<Real, Real> SlepcEigenSolver<T>::get_eigenpair(unsigned int i,
NumericVector<T> &solution_in)
{
int ierr=0;
PetscReal re, im;
// Make sure the NumericVector passed in is really a PetscVector
PetscVector<T>* solution = libmesh_cast_ptr<PetscVector<T>*>(&solution_in);
// real and imaginary part of the ith eigenvalue.
PetscScalar kr, ki;
solution->close();
ierr = EPSGetEigenpair(_eps, i, &kr, &ki, solution->vec(), PETSC_NULL);
LIBMESH_CHKERRABORT(ierr);
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
re = PetscRealPart(kr);
im = PetscImaginaryPart(kr);
#else
re = kr;
im = ki;
#endif
return std::make_pair(re, im);
}
void PetscPreconditioner<T>::clear()
{
if (_pc)
{
int ierr = LibMeshPCDestroy(&_pc);
LIBMESH_CHKERRABORT(ierr);
}
}
void PetscDMNonlinearSolver<T>::init()
{
PetscErrorCode ierr;
DM dm;
this->PetscNonlinearSolver<T>::init();
// Attaching a DM with the function and Jacobian callbacks to SNES.
ierr = DMCreateLibMesh(this->comm().get(), this->system(), &dm); LIBMESH_CHKERRABORT(ierr);
ierr = DMSetFromOptions(dm); LIBMESH_CHKERRABORT(ierr);
ierr = DMSetUp(dm); LIBMESH_CHKERRABORT(ierr);
ierr = SNESSetDM(this->_snes, dm); LIBMESH_CHKERRABORT(ierr);
// SNES now owns the reference to dm.
ierr = DMDestroy(&dm); LIBMESH_CHKERRABORT(ierr);
KSP ksp;
ierr = SNESGetKSP (this->_snes, &ksp); LIBMESH_CHKERRABORT(ierr);
// Set the tolerances for the iterative solver. Use the user-supplied
// tolerance for the relative residual & leave the others at default values
ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,PETSC_DEFAULT, this->max_linear_iterations); LIBMESH_CHKERRABORT(ierr);
// Set the tolerances for the non-linear solver.
ierr = SNESSetTolerances(this->_snes,
this->absolute_residual_tolerance,
this->relative_residual_tolerance,
this->absolute_step_tolerance,
this->max_nonlinear_iterations,
this->max_function_evaluations);
LIBMESH_CHKERRABORT(ierr);
//Pull in command-line options
KSPSetFromOptions(ksp);
SNESSetFromOptions(this->_snes);
}
void PetscMatrix<T>::close () const
{
semiparallel_only();
// BSK - 1/19/2004
// strictly this check should be OK, but it seems to
// fail on matrix-free matrices. Do they falsely
// state they are assembled? Check with the developers...
// if (this->closed())
// return;
PetscErrorCode ierr=0;
ierr = MatAssemblyBegin (_mat, MAT_FINAL_ASSEMBLY);
LIBMESH_CHKERRABORT(ierr);
ierr = MatAssemblyEnd (_mat, MAT_FINAL_ASSEMBLY);
LIBMESH_CHKERRABORT(ierr);
}
Real SlepcEigenSolver<T>::get_relative_error(unsigned int i)
{
int ierr=0;
PetscReal error;
ierr = EPSComputeRelativeError(_eps, i, &error);
LIBMESH_CHKERRABORT(ierr);
return error;
}
void PetscMatrix<T>::zero ()
{
libmesh_assert (this->initialized());
semiparallel_only();
PetscErrorCode ierr=0;
PetscInt m_l, n_l;
ierr = MatGetLocalSize(_mat,&m_l,&n_l);
LIBMESH_CHKERRABORT(ierr);
if (n_l)
{
ierr = MatZeroEntries(_mat);
LIBMESH_CHKERRABORT(ierr);
}
}
void PetscPreconditioner<T>::apply(const NumericVector<T> & x, NumericVector<T> & y)
{
PetscVector<T> & x_pvec = libmesh_cast_ref<PetscVector<T>&>(const_cast<NumericVector<T>&>(x));
PetscVector<T> & y_pvec = libmesh_cast_ref<PetscVector<T>&>(const_cast<NumericVector<T>&>(y));
Vec x_vec = x_pvec.vec();
Vec y_vec = y_pvec.vec();
int ierr = PCApply(_pc,x_vec,y_vec);
LIBMESH_CHKERRABORT(ierr);
}
void PetscDiffSolver::clear()
{
START_LOG("clear()", "PetscDiffSolver");
int ierr=0;
ierr = LibMeshSNESDestroy(&_snes);
LIBMESH_CHKERRABORT(ierr);
STOP_LOG("clear()", "PetscDiffSolver");
}
void PetscMatrix<T>::print_matlab (const std::string name) const
{
libmesh_assert (this->initialized());
semiparallel_only();
// libmesh_assert (this->closed());
this->close();
PetscErrorCode ierr=0;
PetscViewer petsc_viewer;
ierr = PetscViewerCreate (this->comm().get(),
&petsc_viewer);
LIBMESH_CHKERRABORT(ierr);
/**
* Create an ASCII file containing the matrix
* if a filename was provided.
*/
if (name != "NULL")
{
ierr = PetscViewerASCIIOpen( this->comm().get(),
name.c_str(),
&petsc_viewer);
LIBMESH_CHKERRABORT(ierr);
ierr = PetscViewerSetFormat (petsc_viewer,
PETSC_VIEWER_ASCII_MATLAB);
LIBMESH_CHKERRABORT(ierr);
ierr = MatView (_mat, petsc_viewer);
LIBMESH_CHKERRABORT(ierr);
}
/**
* Otherwise the matrix will be dumped to the screen.
*/
else
{
ierr = PetscViewerSetFormat (PETSC_VIEWER_STDOUT_WORLD,
PETSC_VIEWER_ASCII_MATLAB);
LIBMESH_CHKERRABORT(ierr);
ierr = MatView (_mat, PETSC_VIEWER_STDOUT_WORLD);
LIBMESH_CHKERRABORT(ierr);
}
/**
* Destroy the viewer.
*/
ierr = LibMeshPetscViewerDestroy (&petsc_viewer);
LIBMESH_CHKERRABORT(ierr);
}
numeric_index_type PetscMatrix<T>::row_stop () const
{
libmesh_assert (this->initialized());
PetscInt start=0, stop=0;
PetscErrorCode ierr=0;
ierr = MatGetOwnershipRange(_mat, &start, &stop);
LIBMESH_CHKERRABORT(ierr);
return static_cast<numeric_index_type>(stop);
}
numeric_index_type PetscMatrix<T>::n () const
{
libmesh_assert (this->initialized());
PetscInt petsc_m=0, petsc_n=0;
PetscErrorCode ierr=0;
ierr = MatGetSize (_mat, &petsc_m, &petsc_n);
LIBMESH_CHKERRABORT(ierr);
return static_cast<numeric_index_type>(petsc_n);
}
bool PetscMatrix<T>::closed() const
{
libmesh_assert (this->initialized());
PetscErrorCode ierr=0;
PetscBool assembled;
ierr = MatAssembled(_mat, &assembled);
LIBMESH_CHKERRABORT(ierr);
return (assembled == PETSC_TRUE);
}
SNESConvergedReason PetscNonlinearSolver<T>::get_converged_reason()
{
PetscErrorCode ierr=0;
if (this->initialized())
{
ierr = SNESGetConvergedReason(_snes, &_reason);
LIBMESH_CHKERRABORT(ierr);
}
return _reason;
}
void SlepcEigenSolver<T>:: set_slepc_problem_type()
{
int ierr = 0;
switch (this->_eigen_problem_type)
{
case NHEP:
ierr = EPSSetProblemType (_eps, EPS_NHEP); LIBMESH_CHKERRABORT(ierr); return;
case GNHEP:
ierr = EPSSetProblemType (_eps, EPS_GNHEP); LIBMESH_CHKERRABORT(ierr); return;
case HEP:
ierr = EPSSetProblemType (_eps, EPS_HEP); LIBMESH_CHKERRABORT(ierr); return;
case GHEP:
ierr = EPSSetProblemType (_eps, EPS_GHEP); LIBMESH_CHKERRABORT(ierr); return;
default:
libMesh::err << "ERROR: Unsupported SLEPc Eigen Problem: "
<< this->_eigen_problem_type << std::endl
<< "Continuing with SLEPc defaults" << std::endl;
}
}
void PetscPreconditioner<T>::init ()
{
if(!this->_matrix)
{
libMesh::err << "ERROR: No matrix set for PetscPreconditioner, but init() called" << std::endl;
libmesh_error();
}
// Clear the preconditioner in case it has been created in the past
if (!this->_is_initialized)
{
// Should probably use PCReset(), but it's not working at the moment so we'll destroy instead
if (_pc)
{
int ierr = LibMeshPCDestroy(&_pc);
LIBMESH_CHKERRABORT(ierr);
}
int ierr = PCCreate(this->comm().get(),&_pc);
LIBMESH_CHKERRABORT(ierr);
PetscMatrix<T> * pmatrix = libmesh_cast_ptr<PetscMatrix<T>*, SparseMatrix<T> >(this->_matrix);
_mat = pmatrix->mat();
}
int ierr = PCSetOperators(_pc,_mat,_mat,SAME_NONZERO_PATTERN);
LIBMESH_CHKERRABORT(ierr);
// Set the PCType. Note: this used to be done *before* the call to
// PCSetOperators(), and only when !_is_initialized, but
// 1.) Some preconditioners (those employing sub-preconditioners,
// for example) have to call PCSetUp(), and can only do this after
// the operators have been set.
// 2.) It should be safe to call set_petsc_preconditioner_type()
// multiple times.
set_petsc_preconditioner_type(this->_preconditioner_type, _pc);
this->_is_initialized = true;
}
std::pair<unsigned int, unsigned int>
SlepcEigenSolver<T>::solve_generalized (SparseMatrix<T> &matrix_A_in,
ShellMatrix<T> &shell_matrix_B,
int nev, // number of requested eigenpairs
int ncv, // number of basis vectors
const double tol, // solver tolerance
const unsigned int m_its) // maximum number of iterations
{
this->init ();
PetscErrorCode ierr=0;
PetscMatrix<T>* matrix_A = cast_ptr<PetscMatrix<T>*>(&matrix_A_in);
// Close the matrix and vectors in case this wasn't already done.
matrix_A->close ();
// Prepare the matrix.
Mat mat_B;
ierr = MatCreateShell(this->comm().get(),
shell_matrix_B.m(), // Specify the number of local rows
shell_matrix_B.n(), // Specify the number of local columns
PETSC_DETERMINE,
PETSC_DETERMINE,
const_cast<void*>(static_cast<const void*>(&shell_matrix_B)),
&mat_B);
LIBMESH_CHKERRABORT(ierr);
/* Note that the const_cast above is only necessary because PETSc
does not accept a const void*. Inside the member function
_petsc_shell_matrix() below, the pointer is casted back to a
const ShellMatrix<T>*. */
ierr = MatShellSetOperation(mat_B,MATOP_MULT,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
LIBMESH_CHKERRABORT(ierr);
ierr = MatShellSetOperation(mat_B,MATOP_GET_DIAGONAL,reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
LIBMESH_CHKERRABORT(ierr);
return _solve_generalized_helper (matrix_A->mat(), mat_B, nev, ncv, tol, m_its);
}
void SlepcEigenSolver<T>:: set_slepc_position_of_spectrum()
{
int ierr = 0;
switch (this->_position_of_spectrum)
{
case LARGEST_MAGNITUDE:
ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_MAGNITUDE); LIBMESH_CHKERRABORT(ierr); return;
case SMALLEST_MAGNITUDE:
ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_MAGNITUDE); LIBMESH_CHKERRABORT(ierr); return;
case LARGEST_REAL:
ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_REAL); LIBMESH_CHKERRABORT(ierr); return;
case SMALLEST_REAL:
ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_REAL); LIBMESH_CHKERRABORT(ierr); return;
case LARGEST_IMAGINARY:
ierr = EPSSetWhichEigenpairs (_eps, EPS_LARGEST_IMAGINARY); LIBMESH_CHKERRABORT(ierr); return;
case SMALLEST_IMAGINARY:
ierr = EPSSetWhichEigenpairs (_eps, EPS_SMALLEST_IMAGINARY); LIBMESH_CHKERRABORT(ierr); return;
default:
libMesh::err << "ERROR: Unsupported SLEPc position of spectrum: "
<< this->_position_of_spectrum << std::endl;
libmesh_error();
}
}
void SlepcEigenSolver<T>::set_slepc_solver_type()
{
int ierr = 0;
switch (this->_eigen_solver_type)
{
case POWER:
ierr = EPSSetType (_eps, (char*) EPSPOWER); LIBMESH_CHKERRABORT(ierr); return;
case SUBSPACE:
ierr = EPSSetType (_eps, (char*) EPSSUBSPACE); LIBMESH_CHKERRABORT(ierr); return;
case LAPACK:
ierr = EPSSetType (_eps, (char*) EPSLAPACK); LIBMESH_CHKERRABORT(ierr); return;
case ARNOLDI:
ierr = EPSSetType (_eps, (char*) EPSARNOLDI); LIBMESH_CHKERRABORT(ierr); return;
case LANCZOS:
ierr = EPSSetType (_eps, (char*) EPSLANCZOS); LIBMESH_CHKERRABORT(ierr); return;
#if !SLEPC_VERSION_LESS_THAN(2,3,2)
// EPSKRYLOVSCHUR added in 2.3.2
case KRYLOVSCHUR:
ierr = EPSSetType (_eps, (char*) EPSKRYLOVSCHUR); LIBMESH_CHKERRABORT(ierr); return;
#endif
// case ARPACK:
// ierr = EPSSetType (_eps, (char*) EPSARPACK); LIBMESH_CHKERRABORT(ierr); return;
default:
libMesh::err << "ERROR: Unsupported SLEPc Eigen Solver: "
<< Utility::enum_to_string(this->_eigen_solver_type) << std::endl
<< "Continuing with SLEPc defaults" << std::endl;
}
}
void RBConstructionBase<Base>::reset_alternative_solver(
#ifdef LIBMESH_HAVE_PETSC
AutoPtr<LinearSolver<Number> >& ls,
const std::pair<std::string,std::string>& orig
#else
AutoPtr<LinearSolver<Number> >&,
const std::pair<std::string,std::string>&
#endif
)
{
#ifdef LIBMESH_HAVE_PETSC
// If we never switched, we don't need to do anything...
if (this->alternative_solver != "unchanged")
{
// this->linear_solver->set_preconditioner_type(orig_pc);
// Set PC back to its previous type
PetscLinearSolver<Number>* petsc_linear_solver =
libmesh_cast_ptr<PetscLinearSolver<Number>*>(ls.get());
PC pc;
KSP ksp;
if (petsc_linear_solver)
{
int ierr = 0;
pc = petsc_linear_solver->pc();
ierr = PCSetType(pc, orig.first.c_str());
LIBMESH_CHKERRABORT(ierr);
ksp = petsc_linear_solver->ksp();
ierr = KSPSetType(ksp, orig.second.c_str());
LIBMESH_CHKERRABORT(ierr);
}
}
#endif
}
void PetscMatrix<T>::add (const numeric_index_type i,
const numeric_index_type j,
const T value)
{
libmesh_assert (this->initialized());
PetscErrorCode ierr=0;
PetscInt i_val=i, j_val=j;
PetscScalar petsc_value = static_cast<PetscScalar>(value);
ierr = MatSetValues(_mat, 1, &i_val, 1, &j_val,
&petsc_value, ADD_VALUES);
LIBMESH_CHKERRABORT(ierr);
}
void PetscMatrix<T>::clear ()
{
PetscErrorCode ierr=0;
if ((this->initialized()) && (this->_destroy_mat_on_exit))
{
semiparallel_only();
ierr = LibMeshMatDestroy (&_mat);
LIBMESH_CHKERRABORT(ierr);
this->_is_initialized = false;
}
}
void SlepcEigenSolver<T>::attach_deflation_space(NumericVector<T>& deflation_vector_in)
{
this->init();
int ierr = 0;
Vec deflation_vector = (libmesh_cast_ptr<PetscVector<T>*>(&deflation_vector_in))->vec();
Vec* deflation_space = &deflation_vector;
#if SLEPC_VERSION_LESS_THAN(3,1,0)
ierr = EPSAttachDeflationSpace(_eps, 1, deflation_space, PETSC_FALSE);
#else
ierr = EPSSetDeflationSpace(_eps, 1, deflation_space);
#endif
LIBMESH_CHKERRABORT(ierr);
}
void PetscMatrix<T>::add (const T a_in, SparseMatrix<T> &X_in)
{
libmesh_assert (this->initialized());
// sanity check. but this cannot avoid
// crash due to incompatible sparsity structure...
libmesh_assert_equal_to (this->m(), X_in.m());
libmesh_assert_equal_to (this->n(), X_in.n());
PetscScalar a = static_cast<PetscScalar> (a_in);
PetscMatrix<T>* X = libmesh_cast_ptr<PetscMatrix<T>*> (&X_in);
libmesh_assert (X);
PetscErrorCode ierr=0;
// the matrix from which we copy the values has to be assembled/closed
// X->close ();
libmesh_assert(X->closed());
semiparallel_only();
// 2.2.x & earlier style
#if PETSC_VERSION_LESS_THAN(2,3,0)
ierr = MatAXPY(&a, X->_mat, _mat, SAME_NONZERO_PATTERN);
LIBMESH_CHKERRABORT(ierr);
// 2.3.x & newer
#else
ierr = MatAXPY(_mat, a, X->_mat, DIFFERENT_NONZERO_PATTERN);
LIBMESH_CHKERRABORT(ierr);
#endif
}