//==============================================================================
std::ostream& Ifpack_ML::Print(std::ostream& os) const
{
if (!Comm().MyPID()) {
os << endl;
os << "================================================================================" << endl;
os << "Ifpack_ML: " << Label () << endl << endl;
os << "Condition number estimate = " << Condest() << endl;
os << "Global number of rows = " << Matrix_->NumGlobalRows() << endl;
os << endl;
os << "Phase # calls Total Time (s) Total MFlops MFlops/s" << endl;
os << "----- ------- -------------- ------------ --------" << endl;
os << "Initialize() " << std::setw(5) << NumInitialize_
<< " " << std::setw(15) << InitializeTime_
<< " 0.0 0.0" << endl;
os << "Compute() " << std::setw(5) << NumCompute_
<< " " << std::setw(15) << ComputeTime_
<< " " << std::setw(15) << 1.0e-6 * ComputeFlops_;
if (ComputeTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ComputeFlops_ / ComputeTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "ApplyInverse() " << std::setw(5) << NumApplyInverse_
<< " " << std::setw(15) << ApplyInverseTime_
<< " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_;
if (ApplyInverseTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_ / ApplyInverseTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "================================================================================" << endl;
os << endl;
}
return(os);
}
//==============================================================================
ostream& Ifpack_Chebyshev::Print(ostream & os) const
{
double MyMinVal, MyMaxVal;
double MinVal, MaxVal;
if (IsComputed_) {
InvDiagonal_->MinValue(&MyMinVal);
InvDiagonal_->MaxValue(&MyMaxVal);
Comm().MinAll(&MyMinVal,&MinVal,1);
Comm().MinAll(&MyMaxVal,&MaxVal,1);
}
if (!Comm().MyPID()) {
os << endl;
os << "================================================================================" << endl;
os << "Ifpack_Chebyshev" << endl;
os << "Degree of polynomial = " << PolyDegree_ << endl;
os << "Condition number estimate = " << Condest() << endl;
os << "Global number of rows = " << Operator_->OperatorRangeMap().NumGlobalElements64() << endl;
if (IsComputed_) {
os << "Minimum value on stored inverse diagonal = " << MinVal << endl;
os << "Maximum value on stored inverse diagonal = " << MaxVal << endl;
}
if (ZeroStartingSolution_)
os << "Using zero starting solution" << endl;
else
os << "Using input starting solution" << endl;
os << endl;
os << "Phase # calls Total Time (s) Total MFlops MFlops/s" << endl;
os << "----- ------- -------------- ------------ --------" << endl;
os << "Initialize() " << std::setw(5) << NumInitialize_
<< " " << std::setw(15) << InitializeTime_
<< " 0.0 0.0" << endl;
os << "Compute() " << std::setw(5) << NumCompute_
<< " " << std::setw(15) << ComputeTime_
<< " " << std::setw(15) << 1.0e-6 * ComputeFlops_;
if (ComputeTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ComputeFlops_ / ComputeTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "ApplyInverse() " << std::setw(5) << NumApplyInverse_
<< " " << std::setw(15) << ApplyInverseTime_
<< " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_;
if (ApplyInverseTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_ / ApplyInverseTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "================================================================================" << endl;
os << endl;
}
return(os);
}
//=============================================================================
std::ostream&
Ifpack_ICT::Print(std::ostream& os) const
{
if (!Comm().MyPID()) {
os << endl;
os << "================================================================================" << endl;
os << "Ifpack_ICT: " << Label() << endl << endl;
os << "Level-of-fill = " << LevelOfFill() << endl;
os << "Absolute threshold = " << AbsoluteThreshold() << endl;
os << "Relative threshold = " << RelativeThreshold() << endl;
os << "Relax value = " << RelaxValue() << endl;
os << "Condition number estimate = " << Condest() << endl;
os << "Global number of rows = " << Matrix().NumGlobalRows() << endl;
if (IsComputed_) {
os << "Number of nonzeros of H = " << H_->NumGlobalNonzeros() << endl;
os << "nonzeros / rows = "
<< 1.0 * H_->NumGlobalNonzeros() / H_->NumGlobalRows() << endl;
}
os << endl;
os << "Phase # calls Total Time (s) Total MFlops MFlops/s" << endl;
os << "----- ------- -------------- ------------ --------" << endl;
os << "Initialize() " << std::setw(5) << NumInitialize()
<< " " << std::setw(15) << InitializeTime()
<< " 0.0 0.0" << endl;
os << "Compute() " << std::setw(5) << NumCompute()
<< " " << std::setw(15) << ComputeTime()
<< " " << std::setw(15) << 1.0e-6 * ComputeFlops();
if (ComputeTime() != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ComputeFlops() / ComputeTime() << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "ApplyInverse() " << std::setw(5) << NumApplyInverse()
<< " " << std::setw(15) << ApplyInverseTime()
<< " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops();
if (ApplyInverseTime() != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops() / ApplyInverseTime() << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "================================================================================" << endl;
os << endl;
}
return(os);
}
//==============================================================================
ostream& Ifpack_Krylov::Print(ostream & os) const
{
if (!Comm().MyPID()) {
os << endl;
os << "================================================================================" << endl;
os << "Ifpack_Krylov" << endl;
os << "Number of iterations = " << Iterations_ << endl;
os << "Residual Tolerance = " << Tolerance_ << endl;
os << "Solver type (O for CG, 1 for GMRES) = " << SolverType_ << endl;
os << "Preconditioner type = " << PreconditionerType_ << endl;
os << "(0 for none, 1 for Jacobi, 2 for GS, 3 for SGS )" << endl;
os << "Condition number estimate = " << Condest() << endl;
os << "Global number of rows = " << Operator_->OperatorRangeMap().NumGlobalElements64() << endl;
if (ZeroStartingSolution_)
os << "Using zero starting solution" << endl;
else
os << "Using input starting solution" << endl;
os << endl;
os << "Phase # calls Total Time (s) Total MFlops MFlops/s" << endl;
os << "----- ------- -------------- ------------ --------" << endl;
os << "Initialize() " << std::setw(5) << NumInitialize_
<< " " << std::setw(15) << InitializeTime_
<< " 0.0 0.0" << endl;
os << "Compute() " << std::setw(5) << NumCompute_
<< " " << std::setw(15) << ComputeTime_
<< " " << std::setw(15) << 1.0e-6 * ComputeFlops_;
if (ComputeTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ComputeFlops_ / ComputeTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "ApplyInverse() " << std::setw(5) << NumApplyInverse_
<< " " << std::setw(15) << ApplyInverseTime_
<< " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_;
if (ApplyInverseTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_ / ApplyInverseTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "================================================================================" << endl;
os << endl;
}
return(os);
}
//==============================================================================
ostream& Ifpack_PointRelaxation::Print(ostream & os) const
{
double MyMinVal, MyMaxVal;
double MinVal, MaxVal;
if (IsComputed_) {
Diagonal_->MinValue(&MyMinVal);
Diagonal_->MaxValue(&MyMaxVal);
Comm().MinAll(&MyMinVal,&MinVal,1);
Comm().MinAll(&MyMaxVal,&MaxVal,1);
}
if (!Comm().MyPID()) {
os << endl;
os << "================================================================================" << endl;
os << "Ifpack_PointRelaxation" << endl;
os << "Sweeps = " << NumSweeps_ << endl;
os << "damping factor = " << DampingFactor_ << endl;
if (PrecType_ == IFPACK_JACOBI)
os << "Type = Jacobi" << endl;
else if (PrecType_ == IFPACK_GS)
os << "Type = Gauss-Seidel" << endl;
else if (PrecType_ == IFPACK_SGS)
os << "Type = symmetric Gauss-Seidel" << endl;
if (DoBackwardGS_)
os << "Using backward mode (GS only)" << endl;
if (ZeroStartingSolution_)
os << "Using zero starting solution" << endl;
else
os << "Using input starting solution" << endl;
os << "Condition number estimate = " << Condest() << endl;
os << "Global number of rows = " << Matrix_->NumGlobalRows() << endl;
if (IsComputed_) {
os << "Minimum value on stored diagonal = " << MinVal << endl;
os << "Maximum value on stored diagonal = " << MaxVal << endl;
}
os << endl;
os << "Phase # calls Total Time (s) Total MFlops MFlops/s" << endl;
os << "----- ------- -------------- ------------ --------" << endl;
os << "Initialize() " << std::setw(5) << NumInitialize_
<< " " << std::setw(15) << InitializeTime_
<< " 0.0 0.0" << endl;
os << "Compute() " << std::setw(5) << NumCompute_
<< " " << std::setw(15) << ComputeTime_
<< " " << std::setw(15) << 1.0e-6 * ComputeFlops_;
if (ComputeTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ComputeFlops_ / ComputeTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "ApplyInverse() " << std::setw(5) << NumApplyInverse_
<< " " << std::setw(15) << ApplyInverseTime_
<< " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_;
if (ApplyInverseTime_ != 0.0)
os << " " << std::setw(15) << 1.0e-6 * ApplyInverseFlops_ / ApplyInverseTime_ << endl;
else
os << " " << std::setw(15) << 0.0 << endl;
os << "================================================================================" << endl;
os << endl;
}
return(os);
}
