}
void
- SolverBase::set_initial_vector (const PETScWrappers::VectorBase &set_initial_vector)
+ SolverBase::set_initial_vector (const PETScWrappers::VectorBase &this_initial_vector)
{
- initial_vector = (&set_initial_vector);
+ initial_vector = (&this_initial_vector);
}
void
- SolverBase::set_transformation (SLEPcWrappers::TransformationBase &set_transformation)
+ SolverBase::set_transformation (SLEPcWrappers::TransformationBase &this_transformation)
{
- transformation = &set_transformation;
+ transformation = &this_transformation;
}
void
AssertThrow (solver_data.get() != 0, ExcSLEPcWrappersUsageError());
// get converged eigenpair
- int ierr = EPSGetEigenpair(solver_data->eps, index,
- &kr, PETSC_NULL, vr, PETSC_NULL);
+ int ierr = EPSGetEigenpair (solver_data->eps, index,
+ &kr, PETSC_NULL, vr, PETSC_NULL);
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
EPS *
SolverBase::get_EPS ()
{
- if( solver_data.get() == 0 )
+ if (solver_data.get() == 0)
return NULL;
+
return &solver_data->eps;
}
// number of iteration steps to
// the SLEPc convergence
// criterion.
- ierr = EPSSetTolerances(eps, this->solver_control.tolerance(),
- this->solver_control.max_steps());
+ ierr = EPSSetTolerances (eps, this->solver_control.tolerance(),
+ this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
// number of iteration steps to
// the SLEPc convergence
// criterion.
- ierr = EPSSetTolerances(eps, this->solver_control.tolerance(),
- this->solver_control.max_steps());
+ ierr = EPSSetTolerances (eps, this->solver_control.tolerance(),
+ this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
SolverDavidson::set_solver_type (EPS &eps) const
{
int ierr;
- ierr = EPSSetType (eps, const_cast<char *>(EPSDAVIDSON));
+ ierr = EPSSetType (eps, const_cast<char *>(EPSGD));
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
// hand over the absolute
// number of iteration steps to
// the SLEPc convergence
// criterion.
- ierr = EPSSetTolerances(eps, this->solver_control.tolerance(),
- this->solver_control.max_steps());
+ ierr = EPSSetTolerances (eps, this->solver_control.tolerance(),
+ this->solver_control.max_steps());
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
#endif
namespace SLEPcWrappers
{
TransformationBase::TransformationData::~TransformationData ()
- {
- }
+ {}
TransformationBase::TransformationBase ()
- {
- }
+ {}
TransformationBase::~TransformationBase ()
- {
- }
+ {}
void TransformationBase::set_context (EPS &eps)
{
}
/* ------------------- TransformationShift --------------------- */
+
TransformationShift::AdditionalData::
AdditionalData (const double shift_parameter)
:
}
/* ---------------- TransformationShiftInvert ------------------ */
+
TransformationShiftInvert::AdditionalData::
AdditionalData (const double shift_parameter)
:
TransformationShiftInvert::set_transformation_type (ST &st) const
{
int ierr;
+#if DEAL_II_PETSC_VERSION_LT(3,1,0)
ierr = STSetType (st, const_cast<char *>(STSINV));
+#else
+ ierr = STSetType (st, const_cast<char *>(STSINVERT));
+#endif
AssertThrow (ierr == 0, SolverBase::ExcSLEPcError(ierr));
ierr = STSetShift (st, additional_data.shift_parameter);
}
/* --------------- TransformationSpectrumFolding ----------------- */
+
TransformationSpectrumFolding::AdditionalData::
AdditionalData (const double shift_parameter)
:
}
/* ------------------- TransformationCayley --------------------- */
+
TransformationCayley::AdditionalData::
AdditionalData (const double shift_parameter,
const double antishift_parameter)