col_value_ptr = &column_values[0];
}
- const int ierr
- = MatSetValues (matrix, 1, &petsc_i, n_columns, col_index_ptr,
- col_value_ptr, INSERT_VALUES);
+ const int ierr = MatSetValues (matrix, 1, &petsc_i, n_columns,
+ col_index_ptr,
+ col_value_ptr, INSERT_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
col_value_ptr = &column_values[0];
}
- const int ierr
- = MatSetValues (matrix, 1, &petsc_i, n_columns, col_index_ptr,
- col_value_ptr, ADD_VALUES);
+ const int ierr = MatSetValues (matrix, 1, &petsc_i, n_columns,
+ col_index_ptr, col_value_ptr, ADD_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
const PetscInt petsc_i = index;
- const int ierr
- = VecSetValues (vector, 1, &petsc_i, &value, INSERT_VALUES);
+ const int ierr = VecSetValues (vector, 1, &petsc_i, &value, INSERT_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
vector.last_action = VectorOperation::insert;
// use the PETSc function to add something
const PetscInt petsc_i = index;
- const int ierr
- = VecSetValues (vector, 1, &petsc_i, &value, ADD_VALUES);
+ const int ierr = VecSetValues (vector, 1, &petsc_i, &value, ADD_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// add something
const PetscInt petsc_i = index;
const PetscScalar subtractand = -value;
- const int ierr
- = VecSetValues (vector, 1, &petsc_i, &subtractand, ADD_VALUES);
+ const int ierr = VecSetValues (vector, 1, &petsc_i, &subtractand, ADD_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return *this;
const PetscScalar new_value
= static_cast<PetscScalar>(*this) * value;
- const int ierr
- = VecSetValues (vector, 1, &petsc_i, &new_value, INSERT_VALUES);
+ const int ierr = VecSetValues (vector, 1, &petsc_i, &new_value, INSERT_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return *this;
const PetscScalar new_value
= static_cast<PetscScalar>(*this) / value;
- const int ierr
- = VecSetValues (vector, 1, &petsc_i, &new_value, INSERT_VALUES);
+ const int ierr = VecSetValues (vector, 1, &petsc_i, &new_value, INSERT_VALUES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return *this;
{
// use the call sequence indicating only a maximal number of
// elements per row for all rows globally
- const int ierr
- = MatCreateSeqDense (PETSC_COMM_SELF, m, n, PETSC_NULL,
- &matrix);
-
+ const int ierr = MatCreateSeqDense (PETSC_COMM_SELF, m, n, PETSC_NULL,
+ &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
#endif
#if DEAL_II_PETSC_VERSION_LT(3,2,0)
- const int ierr
- = MatZeroRowsIS(matrix, index_set, new_diag_value);
+ const int ierr = MatZeroRowsIS(matrix, index_set, new_diag_value);
#else
- const int ierr
- = MatZeroRowsIS(matrix, index_set, new_diag_value, PETSC_NULL, PETSC_NULL);
+ const int ierr = MatZeroRowsIS(matrix, index_set, new_diag_value, PETSC_NULL,
+ PETSC_NULL);
#endif
AssertThrow (ierr == 0, ExcPETScError(ierr));
PetscScalar value;
- const int ierr
- = MatGetValues (matrix, 1, &petsc_i, 1, &petsc_j,
- &value);
+ const int ierr = MatGetValues (matrix, 1, &petsc_i, 1, &petsc_j,
+ &value);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return value;
{
PetscInt n_rows, n_cols;
- int ierr = MatGetSize (matrix, &n_rows, &n_cols);
+ const int ierr = MatGetSize (matrix, &n_rows, &n_cols);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return n_rows;
{
PetscInt n_rows, n_cols;
- int ierr = MatGetSize (matrix, &n_rows, &n_cols);
+ const int ierr = MatGetSize (matrix, &n_rows, &n_cols);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return n_cols;
{
PetscInt n_rows, n_cols;
- int ierr = MatGetLocalSize (matrix, &n_rows, &n_cols);
+ const int ierr = MatGetLocalSize (matrix, &n_rows, &n_cols);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return n_rows;
MatrixBase::n_nonzero_elements () const
{
MatInfo mat_info;
- const int ierr
- = MatGetInfo (matrix, MAT_GLOBAL_SUM, &mat_info);
+ const int ierr = MatGetInfo (matrix, MAT_GLOBAL_SUM, &mat_info);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return static_cast<size_type>(mat_info.nz_used);
//TODO: this is probably horribly inefficient; we should lobby for a way to
//query this information from PETSc
- int ierr;
- ierr = MatGetRow(*this, row, &ncols, &colnums, &values);
+ int ierr = MatGetRow(*this, row, &ncols, &colnums, &values);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// then restore the matrix and return the number of columns in this row as
{
PetscReal result;
- const int ierr
- = MatNorm (matrix, NORM_1, &result);
+ const int ierr = MatNorm (matrix, NORM_1, &result);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return result;
{
PetscReal result;
- const int ierr
- = MatNorm (matrix, NORM_INFINITY, &result);
+ const int ierr = MatNorm (matrix, NORM_INFINITY, &result);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return result;
{
PetscReal result;
- const int ierr
- = MatNorm (matrix, NORM_FROBENIUS, &result);
+ const int ierr = MatNorm (matrix, NORM_FROBENIUS, &result);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return result;
{
PetscScalar result;
- const int ierr
- = MatGetTrace (matrix, &result);
+ const int ierr = MatGetTrace (matrix, &result);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return result;
{
const PetscScalar factor = 1./a;
const int ierr = MatScale (matrix, factor);
-
AssertThrow (ierr == 0, ExcPETScError(ierr));
return *this;
{
const int ierr = MatAXPY (matrix, factor,
other, DIFFERENT_NONZERO_PATTERN);
- (void)ierr;
-
- Assert (ierr == 0, ExcPETScError(ierr));
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
return *this;
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMult (matrix, src, dst);
- (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMultTranspose (matrix, src, dst);
- (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
Assert (&src != &dst, ExcSourceEqualsDestination());
const int ierr = MatMultTransposeAdd (matrix, src, dst, dst);
- (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
void
MatrixBase::transpose ()
{
- int ierr = MatTranspose(matrix, MAT_REUSE_MATRIX, &matrix);
- (void)ierr;
+ const int ierr = MatTranspose(matrix, MAT_REUSE_MATRIX, &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
{
PetscBooleanType truth;
assert_is_compressed ();
- int ierr = MatIsSymmetric (matrix, tolerance, &truth);
- (void)ierr;
+ const int ierr = MatIsSymmetric (matrix, tolerance, &truth);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return truth;
}
PetscBooleanType truth;
assert_is_compressed ();
- int ierr = MatIsHermitian (matrix, tolerance, &truth);
- (void)ierr;
+ const int ierr = MatIsHermitian (matrix, tolerance, &truth);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return truth;
for (row = loc_range.first; row < loc_range.second; ++row)
{
int ierr = MatGetRow(*this, row, &ncols, &colnums, &values);
- (void)ierr;
AssertThrow (ierr == 0, ExcPETScError(ierr));
for (PetscInt col = 0; col < ncols; ++col)
// to the matrix-vector multiplication
// of this MatrixFree object,
void *this_object;
- int ierr = MatShellGetContext (A, &this_object);
+ const int ierr = MatShellGetContext (A, &this_object);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// call vmult of this object:
this->communicator = other.communicator;
- int ierr = MatCopy(other.matrix, matrix, SAME_NONZERO_PATTERN);
+ const int ierr = MatCopy(other.matrix, matrix, SAME_NONZERO_PATTERN);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
int ierr;
#if DEAL_II_PETSC_VERSION_LT(3,3,0)
- ierr
- = MatCreateMPIAIJ (communicator,
+ ierr = MatCreateMPIAIJ (communicator,
+ local_rows, local_columns,
+ m, n,
+ n_nonzero_per_row, 0,
+ n_offdiag_nonzero_per_row, 0,
+ &matrix);
+#else
+ ierr = MatCreateAIJ (communicator,
local_rows, local_columns,
m, n,
n_nonzero_per_row, 0,
n_offdiag_nonzero_per_row, 0,
&matrix);
-#else
- ierr
- = MatCreateAIJ (communicator,
- local_rows, local_columns,
- m, n,
- n_nonzero_per_row, 0,
- n_offdiag_nonzero_per_row, 0,
- &matrix);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
set_matrix_option (matrix, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE);
#endif
AssertThrow (ierr == 0, ExcPETScError(ierr));
int ierr;
#if DEAL_II_PETSC_VERSION_LT(3,3,0)
- ierr
- = MatCreateMPIAIJ (communicator,
+ ierr = MatCreateMPIAIJ (communicator,
+ local_rows, local_columns,
+ m, n,
+ 0, &int_row_lengths[0],
+ 0, offdiag_row_lengths.size() ? &int_offdiag_row_lengths[0] : 0,
+ &matrix);
+#else
+ ierr = MatCreateAIJ (communicator,
local_rows, local_columns,
m, n,
0, &int_row_lengths[0],
0, offdiag_row_lengths.size() ? &int_offdiag_row_lengths[0] : 0,
&matrix);
-#else
- ierr
- = MatCreateAIJ (communicator,
- local_rows, local_columns,
- m, n,
- 0, &int_row_lengths[0],
- 0, offdiag_row_lengths.size() ? &int_offdiag_row_lengths[0] : 0,
- &matrix);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
//TODO: Sometimes the actual number of nonzero entries allocated is greater than the number of nonzero entries, which petsc will complain about unless explicitly disabled with MatSetOption. There is probably a way to prevent a different number nonzero elements being allocated in the first place. (See also previous TODO).
set_matrix_option (matrix, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE);
// then call the petsc function
// that summarily allocates these
// entries:
- MatMPIAIJSetPreallocationCSR (matrix,
- &rowstart_in_window[0],
- &colnums_in_window[0],
- 0);
+ ierr = MatMPIAIJSetPreallocationCSR (matrix,
+ &rowstart_in_window[0],
+ &colnums_in_window[0],
+ 0);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
}
else
{
PetscInt i=0;
- MatMPIAIJSetPreallocationCSR (matrix,
- &i,
- &i,
- 0);
-
-
+ ierr = MatMPIAIJSetPreallocationCSR (matrix,
+ &i,
+ &i,
+ 0);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
}
compress (dealii::VectorOperation::insert);
// the first _local_ row, i.e. it
// doesn't index into an array for
// _all_ rows.
- const int ierr
- = MatCreateMPIAIJ(communicator,
- local_rows_per_process[this_process],
- local_columns_per_process[this_process],
- sparsity_pattern.n_rows(),
- sparsity_pattern.n_cols(),
- 0, &row_lengths_in_window[0],
- 0, &row_lengths_out_of_window[0],
- &matrix);
+ const int ierr = MatCreateMPIAIJ(communicator,
+ local_rows_per_process[this_process],
+ local_columns_per_process[this_process],
+ sparsity_pattern.n_rows(),
+ sparsity_pattern.n_cols(),
+ 0, &row_lengths_in_window[0],
+ 0, &row_lengths_out_of_window[0],
+ &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
#else //PETSC_VERSION>=2.3.3
// create the matrix. We
// do not set row length but set the
// correct SparsityPattern later.
- int ierr;
-
- ierr = MatCreate(communicator,&matrix);
+ int ierr = MatCreate(communicator,&matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
ierr = MatSetSizes(matrix,
// then call the petsc function
// that summarily allocates these
// entries:
- MatMPIAIJSetPreallocationCSR (matrix,
- &rowstart_in_window[0],
- &colnums_in_window[0],
- 0);
+ ierr = MatMPIAIJSetPreallocationCSR (matrix,
+ &rowstart_in_window[0],
+ &colnums_in_window[0],
+ 0);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
#if DEAL_II_PETSC_VERSION_LT(2,3,3)
// this is only needed for old
#else
ierr = VecDestroy (&vector);
#endif
-
AssertThrow (ierr == 0, ExcPETScError(ierr));
create_vector (n, local_sz);
reinit (v.locally_owned_elements(), v.ghost_indices, v.communicator);
if (!omit_zeroing_entries)
{
- int ierr = VecSet(vector, 0.0);
+ const int ierr = VecSet(vector, 0.0);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
}
Assert (local_size <= n, ExcIndexRange (local_size, 0, n));
ghosted = false;
- const int ierr
- = VecCreateMPI (communicator, local_size, PETSC_DETERMINE,
- &vector);
+ const int ierr = VecCreateMPI (communicator, local_size, PETSC_DETERMINE,
+ &vector);
AssertThrow (ierr == 0, ExcPETScError(ierr));
Assert (size() == n,
:
0);
- int ierr
- = VecCreateGhost(communicator,
- local_size,
- PETSC_DETERMINE,
- ghostindices.size(),
- ptr,
- &vector);
-
+ int ierr = VecCreateGhost(communicator,
+ local_size,
+ PETSC_DETERMINE,
+ ghostindices.size(),
+ ptr,
+ &vector);
AssertThrow (ierr == 0, ExcPETScError(ierr));
Assert (size() == n,
PetscInt nlocal, istart, iend;
int ierr = VecGetArray (vector, &val);
-
AssertThrow (ierr == 0, ExcPETScError(ierr));
ierr = VecGetLocalSize (vector, &nlocal);
-
AssertThrow (ierr == 0, ExcPETScError(ierr));
ierr = VecGetOwnershipRange (vector, &istart, &iend);
-
AssertThrow (ierr == 0, ExcPETScError(ierr));
// save the state of out stream
// completely pointless change in
// spelling Chebyshev between PETSc 3.2
// and 3.3...
- int ierr;
-
#if DEAL_II_PETSC_VERSION_LT(3,3,0)
- ierr = KSPSetType (ksp, KSPCHEBYCHEV);
+ int ierr = KSPSetType (ksp, KSPCHEBYCHEV);
#else
- ierr = KSPSetType (ksp, KSPCHEBYSHEV);
+ int ierr = KSPSetType (ksp, KSPCHEBYSHEV);
#endif
AssertThrow (ierr == 0, ExcPETScError(ierr));
void
SolverCG::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPCG);
+ int ierr = KSPSetType (ksp, KSPCG);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
void
SolverBiCG::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPBICG);
+ int ierr = KSPSetType (ksp, KSPBICG);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
void
SolverGMRES::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPGMRES);
+ int ierr = KSPSetType (ksp, KSPGMRES);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// set the restart parameter from the
void
SolverBicgstab::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPBCGS);
+ int ierr = KSPSetType (ksp, KSPBCGS);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
void
SolverCGS::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPCGS);
+ int ierr = KSPSetType (ksp, KSPCGS);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
void
SolverTCQMR::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPTCQMR);
+ int ierr = KSPSetType (ksp, KSPTCQMR);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
void
SolverLSQR::set_solver_type (KSP &ksp) const
{
- int ierr;
- ierr = KSPSetType (ksp, KSPLSQR);
+ int ierr = KSPSetType (ksp, KSPLSQR);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// in the deal.II solvers, we always
* preconditioner. Its use is due to SparseDirectMUMPS being a direct
* (rather than iterative) solver
*/
- int ierr;
- ierr = KSPSetType (ksp, KSPPREONLY);
+ int ierr = KSPSetType (ksp, KSPPREONLY);
AssertThrow (ierr == 0, ExcPETScError(ierr));
/**
SparseMatrix::SparseMatrix ()
{
const int m=0, n=0, n_nonzero_per_row=0;
- const int ierr
- = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n, n_nonzero_per_row,
- 0, &matrix);
+ const int ierr = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n, n_nonzero_per_row,
+ 0, &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
// use the call sequence indicating only
// a maximal number of elements per row
// for all rows globally
- const int ierr
- = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n, n_nonzero_per_row,
- 0, &matrix);
+ const int ierr = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n,
+ n_nonzero_per_row,
+ 0, &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// set symmetric flag, if so requested
const std::vector<PetscInt>
int_row_lengths (row_lengths.begin(), row_lengths.end());
- const int ierr
- = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n, 0,
- &int_row_lengths[0], &matrix);
+ const int ierr = MatCreateSeqAIJ(PETSC_COMM_SELF, m, n, 0,
+ &int_row_lengths[0], &matrix);
AssertThrow (ierr == 0, ExcPETScError(ierr));
// set symmetric flag, if so requested
SparseMatrix::m () const
{
PetscInt m,n;
- PetscErrorCode ierr = MatGetSize(matrix, &m, &n);
+ const PetscErrorCode ierr = MatGetSize(matrix, &m, &n);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return m;
SparseMatrix::n () const
{
PetscInt m,n;
- PetscErrorCode ierr = MatGetSize(matrix, &m, &n);
+ const PetscErrorCode ierr = MatGetSize(matrix, &m, &n);
AssertThrow (ierr == 0, ExcPETScError(ierr));
return n;
#endif
const InsertMode mode = (add_values ? ADD_VALUES : INSERT_VALUES);
- const int ierr
- = VecSetValues (vector, n_elements, petsc_indices, values,
- mode);
+ const int ierr = VecSetValues (vector, n_elements, petsc_indices,
+ values, mode);
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
{
// Destroy the solver object.
#if DEAL_II_PETSC_VERSION_LT(3,2,0)
- int ierr = EPSDestroy (eps);
+ const int ierr = EPSDestroy (eps);
#else
- int ierr = EPSDestroy (&eps);
+ const int ierr = EPSDestroy (&eps);
#endif
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
SolverBase::set_matrices (const PETScWrappers::MatrixBase &A)
{
// standard eigenspectrum problem
- int ierr = EPSSetOperators (eps, A, PETSC_NULL);
+ const int ierr = EPSSetOperators (eps, A, PETSC_NULL);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
const PETScWrappers::MatrixBase &B)
{
// generalized eigenspectrum problem
- int ierr = EPSSetOperators (eps, A, B);
+ const int ierr = EPSSetOperators (eps, A, B);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
{
// set transformation type if any
// STSetShift is called inside
- int ierr = EPSSetST(eps,transformation.st);
+ const int ierr = EPSSetST(eps,transformation.st);
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
}
Assert(this_initial_vector.l2_norm()>0.0,
ExcMessage("Initial vector should be nonzero."));
- int ierr;
Vec vec = this_initial_vector;
#if DEAL_II_PETSC_VERSION_LT(3,1,0)
- ierr = EPSSetInitialVector (eps, &vec);
+ const int ierr = EPSSetInitialVector (eps, &vec);
#else
- ierr = EPSSetInitialSpace (eps, 1, &vec);
+ const int ierr = EPSSetInitialSpace (eps, 1, &vec);
#endif
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
// set target eigenvalues to solve for
// in all transformation except STSHIFT there is a direct connection between
// the target and the shift, read more on p41 of SLEPc manual.
- int ierr = EPSSetTarget (eps, this_target );
+ const int ierr = EPSSetTarget (eps, this_target );
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
SolverBase::set_which_eigenpairs (const EPSWhich eps_which)
{
// set which portion of the eigenspectrum to solve for
- int ierr = EPSSetWhichEigenpairs (eps, eps_which);
+ const int ierr = EPSSetWhichEigenpairs (eps, eps_which);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
void
SolverBase::set_problem_type (const EPSProblemType eps_problem)
{
- int ierr = EPSSetProblemType (eps, eps_problem);
+ const int ierr = EPSSetProblemType (eps, eps_problem);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
SolverBase::solve (const unsigned int n_eigenpairs,
unsigned int *n_converged)
{
- int ierr;
-
// set number of eigenvectors to compute
- ierr = EPSSetDimensions (eps, n_eigenpairs,
- PETSC_DECIDE, PETSC_DECIDE);
+ int ierr = EPSSetDimensions (eps, n_eigenpairs,
+ PETSC_DECIDE, PETSC_DECIDE);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
// set the solve options to the eigenvalue problem solver context
PETScWrappers::VectorBase &eigenvectors)
{
// get converged eigenpair
- int ierr = EPSGetEigenpair (eps, index,
- &eigenvalues, PETSC_NULL,
- eigenvectors, PETSC_NULL);
+ const int ierr = EPSGetEigenpair (eps, index,
+ &eigenvalues, PETSC_NULL,
+ eigenvectors, PETSC_NULL);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
{
#ifndef PETSC_USE_COMPLEX
// get converged eigenpair
- int ierr = EPSGetEigenpair (eps, index,
- &real_eigenvalues, &imag_eigenvalues,
- real_eigenvectors, imag_eigenvectors);
+ const int ierr = EPSGetEigenpair (eps, index,
+ &real_eigenvalues, &imag_eigenvalues,
+ real_eigenvectors, imag_eigenvectors);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
#else
Assert ((false),
SolverBase (cn, mpi_communicator),
additional_data (data)
{
- int ierr = EPSSetType (eps, const_cast<char *>(EPSKRYLOVSCHUR));
+ const int ierr = EPSSetType (eps, const_cast<char *>(EPSKRYLOVSCHUR));
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
{
TransformationBase::TransformationBase (const MPI_Comm &mpi_communicator)
{
- int ierr = STCreate(mpi_communicator, &st);
+ const int ierr = STCreate(mpi_communicator, &st);
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
}
{
if (st!=NULL)
{
- int ierr = STDestroy(&st);
+ const int ierr = STDestroy(&st);
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
}
}
void TransformationBase::set_matrix_mode(const STMatMode mode)
{
- int ierr = STSetMatMode(st,mode);
+ const int ierr = STSetMatMode(st,mode);
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
}