void
StaggeredStokesPhysicalBoundaryHelper::enforceDivergenceFreeConditionAtBoundary(
Pointer<SideData<NDIM,double> > u_data,
Pointer<Patch<NDIM> > patch) const
{
if (!patch->getPatchGeometry()->getTouchesRegularBoundary()) return;
const int ln = patch->getPatchLevelNumber();
const int patch_num = patch->getPatchNumber();
Pointer<CartesianPatchGeometry<NDIM> > pgeom = patch->getPatchGeometry();
const double* const dx = pgeom->getDx();
const Array<BoundaryBox<NDIM> >& physical_codim1_boxes = d_physical_codim1_boxes[ln].find(patch_num)->second;
const int n_physical_codim1_boxes = physical_codim1_boxes.size();
const std::vector<Pointer<ArrayData<NDIM,bool> > >& dirichlet_bdry_locs = d_dirichlet_bdry_locs[ln].find(patch_num)->second;
for (int n = 0; n < n_physical_codim1_boxes; ++n)
{
const BoundaryBox<NDIM>& bdry_box = physical_codim1_boxes[n];
const unsigned int location_index = bdry_box.getLocationIndex();
const unsigned int bdry_normal_axis = location_index / 2;
const bool is_lower = location_index % 2 == 0;
const Box<NDIM>& bc_coef_box = dirichlet_bdry_locs[n]->getBox();
const ArrayData<NDIM,bool>& bdry_locs_data = *dirichlet_bdry_locs[n];
for (Box<NDIM>::Iterator it(bc_coef_box); it; it++)
{
const Index<NDIM>& i = it();
if (!bdry_locs_data(i,0))
{
// Place i_g in the ghost cell abutting the boundary.
Index<NDIM> i_g = i;
if (is_lower)
{
i_g(bdry_normal_axis) -= 1;
}
else
{
// intentionally blank
}
// Work out from the physical boundary to fill the ghost cell
// values so that the velocity field satisfies the discrete
// divergence-free condition.
for (int k = 0; k < u_data->getGhostCellWidth()(bdry_normal_axis); ++k, i_g(bdry_normal_axis) += (is_lower ? -1 : +1))
{
// Determine the ghost cell value so that the divergence of
// the velocity field is zero in the ghost cell.
SideIndex<NDIM> i_g_s(i_g, bdry_normal_axis, is_lower ? SideIndex<NDIM>::Lower : SideIndex<NDIM>::Upper);
(*u_data)(i_g_s) = 0.0;
double div_u_g = 0.0;
for (unsigned int axis = 0; axis < NDIM; ++axis)
{
const SideIndex<NDIM> i_g_s_upper(i_g,axis,SideIndex<NDIM>::Upper);
const SideIndex<NDIM> i_g_s_lower(i_g,axis,SideIndex<NDIM>::Lower);
div_u_g += ((*u_data)(i_g_s_upper)-(*u_data)(i_g_s_lower))*dx[bdry_normal_axis]/dx[axis];
}
(*u_data)(i_g_s) = (is_lower ? +1.0 : -1.0)*div_u_g;
}
}
}
}
return;
}// enforceDivergenceFreeConditionAtBoundary
void INSStaggeredPressureBcCoef::setBcCoefs(Pointer<ArrayData<NDIM, double> >& acoef_data,
Pointer<ArrayData<NDIM, double> >& bcoef_data,
Pointer<ArrayData<NDIM, double> >& gcoef_data,
const Pointer<Variable<NDIM> >& variable,
const Patch<NDIM>& patch,
const BoundaryBox<NDIM>& bdry_box,
double /*fill_time*/) const
{
#if !defined(NDEBUG)
for (unsigned int d = 0; d < NDIM; ++d)
{
TBOX_ASSERT(d_bc_coefs[d]);
}
TBOX_ASSERT(acoef_data);
TBOX_ASSERT(bcoef_data);
#endif
Box<NDIM> bc_coef_box = acoef_data->getBox();
#if !defined(NDEBUG)
TBOX_ASSERT(bc_coef_box == acoef_data->getBox());
TBOX_ASSERT(bc_coef_box == bcoef_data->getBox());
TBOX_ASSERT(!gcoef_data || (bc_coef_box == gcoef_data->getBox()));
#endif
// Set the unmodified velocity bc coefs.
const unsigned int location_index = bdry_box.getLocationIndex();
const unsigned int bdry_normal_axis = location_index / 2;
const bool is_lower = location_index % 2 == 0;
const double half_time =
d_fluid_solver->getIntegratorTime() + 0.5 * d_fluid_solver->getCurrentTimeStepSize();
d_bc_coefs[bdry_normal_axis]->setBcCoefs(
acoef_data, bcoef_data, gcoef_data, variable, patch, bdry_box, half_time);
// Ensure homogeneous boundary conditions are enforced.
if (d_homogeneous_bc && gcoef_data) gcoef_data->fillAll(0.0);
// Get the target velocity data.
Pointer<SideData<NDIM, double> > u_target_data;
if (d_u_target_data_idx >= 0)
u_target_data = patch.getPatchData(d_u_target_data_idx);
else if (d_target_data_idx >= 0)
u_target_data = patch.getPatchData(d_target_data_idx);
#if !defined(NDEBUG)
TBOX_ASSERT(u_target_data);
#endif
Pointer<SideData<NDIM, double> > u_current_data = patch.getPatchData(
d_fluid_solver->getVelocityVariable(), d_fluid_solver->getCurrentContext());
#if !defined(NDEBUG)
TBOX_ASSERT(u_current_data);
#endif
const Box<NDIM> ghost_box = u_target_data->getGhostBox() * u_current_data->getGhostBox();
for (unsigned int d = 0; d < NDIM; ++d)
{
if (d != bdry_normal_axis)
{
bc_coef_box.lower(d) = std::max(bc_coef_box.lower(d), ghost_box.lower(d));
bc_coef_box.upper(d) = std::min(bc_coef_box.upper(d), ghost_box.upper(d));
}
}
// Update the boundary condition coefficients. Normal velocity boundary
// conditions are converted into Neumann conditions for the pressure, and
// normal traction boundary conditions are converted into Dirichlet
// conditions for the pressure.
const double mu = d_fluid_solver->getStokesSpecifications()->getMu();
Pointer<CartesianPatchGeometry<NDIM> > pgeom = patch.getPatchGeometry();
const double* const dx = pgeom->getDx();
for (Box<NDIM>::Iterator it(bc_coef_box); it; it++)
{
const Index<NDIM>& i = it();
double dummy_val;
double& alpha = acoef_data ? (*acoef_data)(i, 0) : dummy_val;
double& beta = bcoef_data ? (*bcoef_data)(i, 0) : dummy_val;
double& gamma = gcoef_data ? (*gcoef_data)(i, 0) : dummy_val;
const bool velocity_bc = MathUtilities<double>::equalEps(alpha, 1.0);
const bool traction_bc = MathUtilities<double>::equalEps(beta, 1.0);
#if !defined(NDEBUG)
TBOX_ASSERT((velocity_bc || traction_bc) && !(velocity_bc && traction_bc));
#endif
if (velocity_bc)
{
alpha = 0.0;
beta = 1.0;
gamma = 0.0;
}
else if (traction_bc)
{
switch (d_traction_bc_type)
{
case TRACTION: // -p + 2*mu*du_n/dx_n = g.
{
// Place i_i in the interior cell abutting the boundary, and
// place i_g in the ghost cell abutting the boundary.
Index<NDIM> i_i(i), i_g(i);
if (is_lower)
{
i_g(bdry_normal_axis) -= 1;
}
else
{
i_i(bdry_normal_axis) -= 1;
}
// The boundary condition is -p + 2*mu*du_n/dx_n = g.
//
// Because p is centered about t^{n+1/2}, we compute this
// as:
//
// p^{n+1/2} = mu*du_n/dx_n^{n} + mu*du_n/dx_n^{n+1} - g^{n+1/2}.
static const int NVALS = 3;
double u_current[NVALS], u_new[NVALS];
SideIndex<NDIM> i_s(i_i,
bdry_normal_axis,
is_lower ? SideIndex<NDIM>::Lower :
SideIndex<NDIM>::Upper);
for (int k = 0; k < NVALS; ++k, i_s(bdry_normal_axis) += (is_lower ? 1 : -1))
{
u_current[k] = (*u_current_data)(i_s);
u_new[k] = (*u_target_data)(i_s);
}
const double h = dx[bdry_normal_axis];
const double du_norm_current_dx_norm =
(is_lower ? +1.0 : -1.0) *
(2.0 * u_current[1] - 1.5 * u_current[0] - 0.5 * u_current[2]) / h;
const double du_norm_new_dx_norm =
(is_lower ? +1.0 : -1.0) *
(2.0 * u_new[1] - 1.5 * u_new[0] - 0.5 * u_new[2]) / h;
alpha = 1.0;
beta = 0.0;
gamma = (d_homogeneous_bc ? 0.0 : mu * du_norm_current_dx_norm) +
mu * du_norm_new_dx_norm - gamma;
break;
}
case PSEUDO_TRACTION: // -p = g.
{
alpha = 1.0;
beta = 0.0;
gamma = -gamma;
break;
}
default:
{
TBOX_ERROR(
"INSStaggeredPressureBcCoef::setBcCoefs(): unrecognized or unsupported "
"traction boundary condition type: "
<< enum_to_string<TractionBcType>(d_traction_bc_type) << "\n");
}
}
}
else
{
TBOX_ERROR("this statement should not be reached!\n");
}
}
return;
} // setBcCoefs
