void average_down (MultiFab& S_fine, MultiFab& S_crse,
int scomp, int ncomp, const IntVect& ratio)
{
BL_ASSERT(S_crse.nComp() == S_fine.nComp());
//
// Coarsen() the fine stuff on processors owning the fine data.
//
BoxArray crse_S_fine_BA = S_fine.boxArray(); crse_S_fine_BA.coarsen(ratio);
MultiFab crse_S_fine(crse_S_fine_BA,ncomp,0);
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(crse_S_fine,true); mfi.isValid(); ++mfi)
{
// NOTE: The tilebox is defined at the coarse level.
const Box& tbx = mfi.tilebox();
// NOTE: We copy from component scomp of the fine fab into component 0 of the crse fab
// because the crse fab is a temporary which was made starting at comp 0, it is
// not part of the actual crse multifab which came in.
BL_FORT_PROC_CALL(BL_AVGDOWN,bl_avgdown)
(tbx.loVect(), tbx.hiVect(),
BL_TO_FORTRAN_N(S_fine[mfi],scomp),
BL_TO_FORTRAN_N(crse_S_fine[mfi],0),
ratio.getVect(),&ncomp);
}
S_crse.copy(crse_S_fine,0,scomp,ncomp);
}
void
AuxBoundaryData::copyTo (MultiFab& mf,
int src_comp,
int dst_comp,
int num_comp) const
{
BL_ASSERT(m_initialized);
if (!m_empty && mf.size() > 0)
{
mf.copy(m_fabs,src_comp,dst_comp,num_comp);
}
}
void average_down (MultiFab& S_fine, MultiFab& S_crse, const Geometry& fgeom, const Geometry& cgeom,
int scomp, int ncomp, const IntVect& ratio)
{
if (S_fine.is_nodal() || S_crse.is_nodal())
{
BoxLib::Error("Can't use BoxLib::average_down for nodal MultiFab!");
}
#if (BL_SPACEDIM == 3)
BoxLib::average_down(S_fine, S_crse, scomp, ncomp, ratio);
return;
#else
BL_ASSERT(S_crse.nComp() == S_fine.nComp());
//
// Coarsen() the fine stuff on processors owning the fine data.
//
const BoxArray& fine_BA = S_fine.boxArray();
BoxArray crse_S_fine_BA = fine_BA;
crse_S_fine_BA.coarsen(ratio);
MultiFab crse_S_fine(crse_S_fine_BA,ncomp,0);
MultiFab fvolume;
fgeom.GetVolume(fvolume, fine_BA, 0);
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(crse_S_fine,true); mfi.isValid(); ++mfi)
{
// NOTE: The tilebox is defined at the coarse level.
const Box& tbx = mfi.tilebox();
// NOTE: We copy from component scomp of the fine fab into component 0 of the crse fab
// because the crse fab is a temporary which was made starting at comp 0, it is
// not part of the actual crse multifab which came in.
BL_FORT_PROC_CALL(BL_AVGDOWN_WITH_VOL,bl_avgdown_with_vol)
(tbx.loVect(), tbx.hiVect(),
BL_TO_FORTRAN_N(S_fine[mfi],scomp),
BL_TO_FORTRAN_N(crse_S_fine[mfi],0),
BL_TO_FORTRAN(fvolume[mfi]),
ratio.getVect(),&ncomp);
}
S_crse.copy(crse_S_fine,0,scomp,ncomp);
#endif
}
void
MCMultiGrid::residualCorrectionForm (MultiFab& resL,
const MultiFab& rhsL,
MultiFab& solnL,
const MultiFab& inisol,
MCBC_Mode bc_mode,
int level)
{
//
// Using the linearity of the operator, Lp, we can solve this system
// instead by solving for the correction required to the initial guess.
//
initialsolution->copy(inisol);
solnL.copy(inisol);
Lp.residual(resL, rhsL, solnL, level, bc_mode);
}
int
MultiGrid::solve_ (MultiFab& _sol,
Real eps_rel,
Real eps_abs,
LinOp::BC_Mode bc_mode,
Real bnorm,
Real resnorm0)
{
BL_PROFILE("MultiGrid::solve_()");
//
// If do_fixed_number_of_iters = 1, then do maxiter iterations without checking for convergence
//
// If do_fixed_number_of_iters = 0, then relax system maxiter times,
// and stop if relative error <= _eps_rel or if absolute err <= _abs_eps
//
const Real strt_time = ParallelDescriptor::second();
const int level = 0;
//
// We take the max of the norms of the initial RHS and the initial residual in order to capture both cases
//
Real norm_to_test_against;
bool using_bnorm;
if (bnorm >= resnorm0)
{
norm_to_test_against = bnorm;
using_bnorm = true;
} else {
norm_to_test_against = resnorm0;
using_bnorm = false;
}
int returnVal = 0;
Real error = resnorm0;
//
// Note: if eps_rel, eps_abs < 0 then that test is effectively bypassed
//
if ( ParallelDescriptor::IOProcessor() && eps_rel < 1.0e-16 && eps_rel > 0 )
{
std::cout << "MultiGrid: Tolerance "
<< eps_rel
<< " < 1e-16 is probably set too low" << '\n';
}
//
// We initially define norm_cor based on the initial solution only so we can use it in the very first iteration
// to decide whether the problem is already solved (this is relevant if the previous solve used was only solved
// according to the Anorm test and not the bnorm test).
//
Real norm_cor = norm_inf(*initialsolution,true);
ParallelDescriptor::ReduceRealMax(norm_cor);
int nit = 1;
const Real norm_Lp = Lp.norm(0, level);
Real cg_time = 0;
if ( use_Anorm_for_convergence == 1 )
{
//
// Don't need to go any further -- no iterations are required
//
if (error <= eps_abs || error < eps_rel*(norm_Lp*norm_cor+norm_to_test_against))
{
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
std::cout << " Problem is already converged -- no iterations required\n";
}
return 1;
}
for ( ;
( (error > eps_abs &&
error > eps_rel*(norm_Lp*norm_cor+norm_to_test_against)) ||
(do_fixed_number_of_iters == 1) )
&& nit <= maxiter;
++nit)
{
relax(*cor[level], *rhs[level], level, eps_rel, eps_abs, bc_mode, cg_time);
Real tmp[2] = { norm_inf(*cor[level],true), errorEstimate(level,bc_mode,true) };
ParallelDescriptor::ReduceRealMax(tmp,2);
norm_cor = tmp[0];
error = tmp[1];
if ( ParallelDescriptor::IOProcessor() && verbose > 1 )
{
const Real rel_error = error / norm_to_test_against;
Spacer(std::cout, level);
if (using_bnorm)
{
std::cout << "MultiGrid: Iteration "
<< nit
<< " resid/bnorm = "
<< rel_error << '\n';
} else {
std::cout << "MultiGrid: Iteration "
<< nit
<< " resid/resid0 = "
<< rel_error << '\n';
}
}
}
}
else
{
//
// Don't need to go any further -- no iterations are required
//
if (error <= eps_abs || error < eps_rel*norm_to_test_against)
{
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
std::cout << " Problem is already converged -- no iterations required\n";
}
return 1;
}
for ( ;
( (error > eps_abs &&
error > eps_rel*norm_to_test_against) ||
(do_fixed_number_of_iters == 1) )
&& nit <= maxiter;
++nit)
{
relax(*cor[level], *rhs[level], level, eps_rel, eps_abs, bc_mode, cg_time);
error = errorEstimate(level, bc_mode);
if ( ParallelDescriptor::IOProcessor() && verbose > 1 )
{
const Real rel_error = error / norm_to_test_against;
Spacer(std::cout, level);
if (using_bnorm)
{
std::cout << "MultiGrid: Iteration "
<< nit
<< " resid/bnorm = "
<< rel_error << '\n';
} else {
std::cout << "MultiGrid: Iteration "
<< nit
<< " resid/resid0 = "
<< rel_error << '\n';
}
}
}
}
Real run_time = (ParallelDescriptor::second() - strt_time);
if ( verbose > 0 )
{
if ( ParallelDescriptor::IOProcessor() )
{
const Real rel_error = error / norm_to_test_against;
Spacer(std::cout, level);
if (using_bnorm)
{
std::cout << "MultiGrid: Iteration "
<< nit-1
<< " resid/bnorm = "
<< rel_error << '\n';
} else {
std::cout << "MultiGrid: Iteration "
<< nit-1
<< " resid/resid0 = "
<< rel_error << '\n';
}
}
if ( verbose > 1 )
{
Real tmp[2] = { run_time, cg_time };
ParallelDescriptor::ReduceRealMax(tmp,2,ParallelDescriptor::IOProcessorNumber());
if ( ParallelDescriptor::IOProcessor() )
std::cout << ", Solve time: " << tmp[0] << ", CG time: " << tmp[1];
}
if ( ParallelDescriptor::IOProcessor() ) std::cout << '\n';
}
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
if ( do_fixed_number_of_iters == 1)
{
std::cout << " Did fixed number of iterations: " << maxiter << std::endl;
}
else if ( error < eps_rel*norm_to_test_against )
{
std::cout << " Converged res < eps_rel*max(bnorm,res_norm)\n";
}
else if ( (use_Anorm_for_convergence == 1) && (error < eps_rel*norm_Lp*norm_cor) )
{
std::cout << " Converged res < eps_rel*Anorm*sol\n";
}
else if ( error < eps_abs )
{
std::cout << " Converged res < eps_abs\n";
}
}
//
// Omit ghost update since maybe not initialized in calling routine.
// Add to boundary values stored in initialsolution.
//
_sol.copy(*cor[level]);
_sol.plus(*initialsolution,0,_sol.nComp(),0);
if ( use_Anorm_for_convergence == 1 )
{
if ( do_fixed_number_of_iters == 1 ||
error <= eps_rel*(norm_Lp*norm_cor+norm_to_test_against) ||
error <= eps_abs )
returnVal = 1;
}
else
{
if ( do_fixed_number_of_iters == 1 ||
error <= eps_rel*(norm_to_test_against) ||
error <= eps_abs )
returnVal = 1;
}
//
// Otherwise, failed to solve satisfactorily
//
return returnVal;
}
int
MCMultiGrid::solve_ (MultiFab& _sol,
Real eps_rel,
Real eps_abs,
MCBC_Mode bc_mode,
int level)
{
//
// Relax system maxiter times, stop if relative error <= _eps_rel or
// if absolute err <= _abs_eps
//
const Real strt_time = ParallelDescriptor::second();
//
// Elide a reduction by doing these together.
//
Real tmp[2] = { norm_inf(*rhs[level],true), errorEstimate(level,bc_mode,true) };
ParallelDescriptor::ReduceRealMax(tmp,2);
const Real norm_rhs = tmp[0];
const Real error0 = tmp[1];
int returnVal = 0;
Real error = error0;
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
Spacer(std::cout, level);
std::cout << "MCMultiGrid: Initial rhs = " << norm_rhs << '\n';
std::cout << "MCMultiGrid: Initial error (error0) = " << error0 << '\n';
}
if ( ParallelDescriptor::IOProcessor() && eps_rel < 1.0e-16 && eps_rel > 0 )
{
std::cout << "MCMultiGrid: Tolerance "
<< eps_rel
<< " < 1e-16 is probably set too low" << '\n';
}
//
// Initialize correction to zero at this level (auto-filled at levels below)
//
(*cor[level]).setVal(0.0);
//
// Note: if eps_rel, eps_abs < 0 then that test is effectively bypassed.
//
int nit = 1;
const Real new_error_0 = norm_rhs;
//const Real norm_Lp = Lp.norm(0, level);
for ( ;
error > eps_abs &&
error > eps_rel*norm_rhs &&
nit <= maxiter;
++nit)
{
relax(*cor[level], *rhs[level], level, eps_rel, eps_abs, bc_mode);
error = errorEstimate(level,bc_mode);
if ( ParallelDescriptor::IOProcessor() && verbose > 1 )
{
const Real rel_error = (error0 != 0) ? error/new_error_0 : 0;
Spacer(std::cout, level);
std::cout << "MCMultiGrid: Iteration "
<< nit
<< " error/error0 = "
<< rel_error << '\n';
}
}
Real run_time = (ParallelDescriptor::second() - strt_time);
if ( verbose > 0 )
{
if ( ParallelDescriptor::IOProcessor() )
{
const Real rel_error = (error0 != 0) ? error/error0 : 0;
Spacer(std::cout, level);
std::cout << "MCMultiGrid: Final Iter. "
<< nit-1
<< " error/error0 = "
<< rel_error;
}
if ( verbose > 1 )
{
ParallelDescriptor::ReduceRealMax(run_time);
if ( ParallelDescriptor::IOProcessor() )
std::cout << ", Solve time: " << run_time << '\n';
}
}
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
if ( error < eps_rel*norm_rhs )
{
std::cout << " Converged res < eps_rel*bnorm\n";
}
else if ( error < eps_abs )
{
std::cout << " Converged res < eps_abs\n";
}
}
//
// Omit ghost update since maybe not initialized in calling routine.
// Add to boundary values stored in initialsolution.
//
_sol.copy(*cor[level]);
_sol.plus(*initialsolution,0,_sol.nComp(),0);
if ( error <= eps_rel*(norm_rhs) ||
error <= eps_abs )
returnVal = 1;
//
// Otherwise, failed to solve satisfactorily
//
return returnVal;
}