static
Real
norm_inf (const MultiFab& res, bool local = false)
{
Real restot = res.norm0(0, true);
if ( !local )
ParallelDescriptor::ReduceRealMax(restot);
return restot;
}
void solve_with_HPGMG(MultiFab& soln, MultiFab& gphi, Real a, Real b, MultiFab& alpha, PArray<MultiFab>& beta,
MultiFab& beta_cc, MultiFab& rhs, const BoxArray& bs, const Geometry& geom, int n_cell)
{
BndryData bd(bs, 1, geom);
set_boundary(bd, rhs, 0);
ABecLaplacian abec_operator(bd, dx);
abec_operator.setScalars(a, b);
abec_operator.setCoefficients(alpha, beta);
int minCoarseDim;
if (domain_boundary_condition == BC_PERIODIC)
{
minCoarseDim = 2; // avoid problems with black box calculation of D^{-1} for poisson with periodic BC's on a 1^3 grid
}
else
{
minCoarseDim = 1; // assumes you can drop order on the boundaries
}
level_type level_h;
mg_type MG_h;
int numVectors = 12;
int my_rank = 0, num_ranks = 1;
#ifdef BL_USE_MPI
MPI_Comm_size (MPI_COMM_WORLD, &num_ranks);
MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
#endif /* BL_USE_MPI */
const double h0 = dx[0];
// Create the geometric structure of the HPGMG grid using the RHS MultiFab as
// a template. This doesn't copy any actual data.
CreateHPGMGLevel(&level_h, rhs, n_cell, max_grid_size, my_rank, num_ranks, domain_boundary_condition, numVectors, h0);
// Set up the coefficients for the linear operator L.
SetupHPGMGCoefficients(a, b, alpha, beta_cc, &level_h);
// Now that the HPGMG grid is built, populate it with RHS data.
ConvertToHPGMGLevel(rhs, n_cell, max_grid_size, &level_h, VECTOR_F);
#ifdef USE_HELMHOLTZ
if (ParallelDescriptor::IOProcessor()) {
std::cout << "Creating Helmholtz (a=" << a << ", b=" << b << ") test problem" << std::endl;;
}
#else
if (ParallelDescriptor::IOProcessor()) {
std::cout << "Creating Poisson (a=" << a << ", b=" << b << ") test problem" << std::endl;;
}
#endif /* USE_HELMHOLTZ */
if (level_h.boundary_condition.type == BC_PERIODIC)
{
double average_value_of_f = mean (&level_h, VECTOR_F);
if (average_value_of_f != 0.0)
{
if (ParallelDescriptor::IOProcessor())
{
std::cerr << "WARNING: Periodic boundary conditions, but f does not sum to zero... mean(f)=" << average_value_of_f << std::endl;
}
//shift_vector(&level_h,VECTOR_F,VECTOR_F,-average_value_of_f);
}
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
rebuild_operator(&level_h,NULL,a,b); // i.e. calculate Dinv and lambda_max
MGBuild(&MG_h,&level_h,a,b,minCoarseDim,ParallelDescriptor::Communicator()); // build the Multigrid Hierarchy
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if (ParallelDescriptor::IOProcessor())
std::cout << std::endl << std::endl << "===== STARTING SOLVE =====" << std::endl << std::flush;
MGResetTimers (&MG_h);
zero_vector (MG_h.levels[0], VECTOR_U);
#ifdef USE_FCYCLES
FMGSolve (&MG_h, 0, VECTOR_U, VECTOR_F, a, b, tolerance_abs, tolerance_rel);
#else
MGSolve (&MG_h, 0, VECTOR_U, VECTOR_F, a, b, tolerance_abs, tolerance_rel);
#endif /* USE_FCYCLES */
MGPrintTiming (&MG_h, 0); // don't include the error check in the timing results
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if (ParallelDescriptor::IOProcessor())
std::cout << std::endl << std::endl << "===== Performing Richardson error analysis ==========================" << std::endl;
// solve A^h u^h = f^h
// solve A^2h u^2h = f^2h
// solve A^4h u^4h = f^4h
// error analysis...
MGResetTimers(&MG_h);
const double dtol = tolerance_abs;
const double rtol = tolerance_rel;
int l;for(l=0;l<3;l++){
if(l>0)restriction(MG_h.levels[l],VECTOR_F,MG_h.levels[l-1],VECTOR_F,RESTRICT_CELL);
zero_vector(MG_h.levels[l],VECTOR_U);
#ifdef USE_FCYCLES
FMGSolve(&MG_h,l,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#else
MGSolve(&MG_h,l,VECTOR_U,VECTOR_F,a,b,dtol,rtol);
#endif
}
richardson_error(&MG_h,0,VECTOR_U);
// Now convert solution from HPGMG back to rhs MultiFab.
ConvertFromHPGMGLevel(soln, &level_h, VECTOR_U);
const double norm_from_HPGMG = norm(&level_h, VECTOR_U);
const double mean_from_HPGMG = mean(&level_h, VECTOR_U);
const Real norm0 = soln.norm0();
const Real norm2 = soln.norm2();
if (ParallelDescriptor::IOProcessor()) {
std::cout << "mean from HPGMG: " << mean_from_HPGMG << std::endl;
std::cout << "norm from HPGMG: " << norm_from_HPGMG << std::endl;
std::cout << "norm0 of RHS copied to MF: " << norm0 << std::endl;
std::cout << "norm2 of RHS copied to MF: " << norm2 << std::endl;
}
// Write the MF to disk for comparison with the in-house solver
if (plot_soln)
{
writePlotFile("SOLN-HPGMG", soln, geom);
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
MGDestroy(&MG_h);
destroy_level(&level_h);
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PArray<MultiFab> grad_phi(BL_SPACEDIM, PArrayManage);
for (int n = 0; n < BL_SPACEDIM; ++n)
grad_phi.set(n, new MultiFab(BoxArray(soln.boxArray()).surroundingNodes(n), 1, 0));
#if (BL_SPACEDIM == 2)
abec_operator.compFlux(grad_phi[0],grad_phi[1],soln);
#elif (BL_SPACEDIM == 3)
abec_operator.compFlux(grad_phi[0],grad_phi[1],grad_phi[2],soln);
#endif
// Average edge-centered gradients to cell centers.
BoxLib::average_face_to_cellcenter(gphi, grad_phi, geom);
}
static
Real
norm_inf (const MultiFab& res, bool local = false)
{
return res.norm0(0,0,local);
}