boost::shared_ptr<SAMRAI::hier::PatchData> CleverSideDataFactory<TYPE>::allocate(
const SAMRAI::hier::Patch& patch) const
{
return boost::make_shared<CleverSideData<TYPE> >(
patch.getBox(),
d_depth,
d_ghosts);
}
void CleverNodeInjection<TYPE>::coarsen(
SAMRAI::hier::Patch& coarse,
const SAMRAI::hier::Patch& fine,
const int dst_component,
const int src_component,
const SAMRAI::hier::Box& coarse_box,
const SAMRAI::hier::IntVector& ratio) const
{
boost::shared_ptr<CleverNodeData<TYPE> > fine_data(
SHARED_PTR_CAST(CleverNodeData<TYPE> ,
fine.getPatchData(src_component)));
boost::shared_ptr<CleverNodeData<TYPE> > coarse_data(
SHARED_PTR_CAST(CleverNodeData<TYPE> ,
coarse.getPatchData(dst_component)));
const SAMRAI::hier::Box coarse_ghost_box =
SAMRAI::pdat::NodeGeometry::toNodeBox(coarse_data->getGhostBox());
const SAMRAI::hier::Box fine_ghost_box =
SAMRAI::pdat::NodeGeometry::toNodeBox(fine_data->getGhostBox());
const hier::Index filo = fine_data->getGhostBox().lower();
const hier::Index fihi = fine_data->getGhostBox().upper();
const hier::Index cilo = coarse_data->getGhostBox().lower();
const hier::Index cihi = coarse_data->getGhostBox().upper();
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
for(int depth = 0; depth < coarse_data->getDepth(); depth++) {
if (fine.getDim() == SAMRAI::tbox::Dimension(2)) {
F90_FUNC(conavgclevernodedoub2d, CONAVGCLEVERNODEDOUB2D)
(ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fine_data->getPointer(depth),
coarse_data->getPointer(depth));
} else {
TBOX_ERROR("CleverNodeInjection error...\n"
<< "dim != 2 not supported." << std::endl);
}
}
}
void
Elastic::FAC::pack_v_v_rhs(double* buffer,
const SAMRAI::hier::Patch& patch,
const SAMRAI::hier::Box& region,
const std::string& variable_name,
const int &depth) const
{
boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr;
if (variable_name == "Displacement") {
v_ptr = boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(v_id));
}
else if ("Fault Correction + RHS" == variable_name)
{
v_ptr = boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(v_rhs_id));
}
else
{
TBOX_ERROR("Unregistered variable name '" << variable_name << "' in\n"
<< "Elastic::FAC::packDerivedDataIntoDoubleBuffer");
}
SAMRAI::pdat::SideData<double>& v = *v_ptr;
if(d_dim.getValue()==2)
{
const SAMRAI::hier::Index ip(1,0), jp(0,1);
SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
for (SAMRAI::pdat::CellIterator
icell(SAMRAI::pdat::CellGeometry::begin(region));
icell!=iend; ++icell)
{
const SAMRAI::pdat::CellIndex ¢er(*icell);
const SAMRAI::pdat::SideIndex
x(center,0,SAMRAI::pdat::SideIndex::Lower),
y(center,1,SAMRAI::pdat::SideIndex::Lower);
double vx=v(x);
double vy=v(y);
if(!offset_vector_on_output)
{
vx=(v(x+ip) + vx)/2;
vy=(v(y+jp) + vy)/2;
}
if (0==depth)
{
*buffer = vx;
}
else
{
*buffer = vy;
}
buffer = buffer + 1;
}
}
else
{
const SAMRAI::hier::Index ip(1,0,0), jp(0,1,0), kp(0,0,1);
SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
for (SAMRAI::pdat::CellIterator
icell(SAMRAI::pdat::CellGeometry::begin(region));
icell!=iend; ++icell)
{
const SAMRAI::pdat::CellIndex ¢er(*icell);
const SAMRAI::pdat::SideIndex
x(center,0,SAMRAI::pdat::SideIndex::Lower),
y(center,1,SAMRAI::pdat::SideIndex::Lower),
z(center,2,SAMRAI::pdat::SideIndex::Lower);
double vx=v(x);
double vy=v(y);
double vz=v(z);
if(!offset_vector_on_output)
{
vx=(v(x+ip) + vx)/2;
vy=(v(y+jp) + vy)/2;
vz=(v(z+kp) + vz)/2;
}
if (0==depth)
{
*buffer = vx;
}
else if (1==depth)
{
*buffer = vy;
}
else
{
*buffer = vz;
}
++buffer;
}
}
}
void
Stokes::V_Coarsen_Patch_Strategy::postprocessCoarsen_2D
(SAMRAI::hier::Patch& coarse,
const SAMRAI::hier::Patch& fine,
const SAMRAI::hier::Box& ,
const SAMRAI::hier::IntVector& )
{
/* Fix up the boundary elements by iterating through the boundary
boxes */
/* We only care about edges, not corners, so we only iterate over
edge boundary boxes. */
const std::vector<SAMRAI::hier::BoundaryBox>
&boundaries=coarse_fine[fine.getPatchLevelNumber()]->getEdgeBoundaries(coarse.getGlobalId());
boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_fine =
boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(fine.getPatchData(v_id));
boost::shared_ptr<SAMRAI::pdat::SideData<double> > v =
boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(coarse.getPatchData(v_id));
TBOX_ASSERT(v);
TBOX_ASSERT(v_fine);
TBOX_ASSERT(v_fine->getDepth() == v->getDepth());
TBOX_ASSERT(v->getDepth() == 1);
SAMRAI::hier::Box gbox(v_fine->getGhostBox());
SAMRAI::hier::Index ip(1,0), jp(0,1);
for(size_t mm=0; mm<boundaries.size(); ++mm)
{
SAMRAI::hier::Box bbox=boundaries[mm].getBox();
int location_index=boundaries[mm].getLocationIndex();
SAMRAI::hier::Index
lower=SAMRAI::hier::Index::coarsen(bbox.lower(),
SAMRAI::hier::Index(2,2)),
upper=SAMRAI::hier::Index::coarsen(bbox.upper(),
SAMRAI::hier::Index(2,2));
for(int j=lower(1); j<=upper(1); ++j)
for(int i=lower(0); i<=upper(0); ++i)
{
/* Fix vx */
if(location_index==0)
{
SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),0,
SAMRAI::pdat::SideIndex::Upper);
SAMRAI::pdat::SideIndex center(coarse*2);
if(center[1]>=gbox.lower(1) && center[1]<gbox.upper(1))
{
(*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+jp))/2;
}
}
else if(location_index==1)
{
SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),0,
SAMRAI::pdat::SideIndex::Lower);
SAMRAI::pdat::SideIndex center(coarse*2);
if(center[1]>=gbox.lower(1) && center[1]<gbox.upper(1))
{
(*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+jp))/2;
}
}
/* Fix vy */
else if(location_index==2)
{
SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),1,
SAMRAI::pdat::SideIndex::Upper);
SAMRAI::pdat::SideIndex center(coarse*2);
if(center[0]>=gbox.lower(0) && center[0]<gbox.upper(0))
{
(*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+ip))/2;
}
}
else if(location_index==3)
{
SAMRAI::pdat::SideIndex coarse(SAMRAI::hier::Index(i,j),1,
SAMRAI::pdat::SideIndex::Lower);
SAMRAI::pdat::SideIndex center(coarse*2);
if(center[0]>=gbox.lower(0) && center[0]<gbox.upper(0))
{
(*v)(coarse)=((*v_fine)(center) + (*v_fine)(center+ip))/2;
}
}
else
{
abort();
}
}
}
}
void Stokes::FACOps::residual_3D
(SAMRAI::pdat::CellData<double> &p,
SAMRAI::pdat::SideData<double> &v,
SAMRAI::pdat::CellData<double> &cell_viscosity,
SAMRAI::pdat::CellData<double> &p_rhs,
SAMRAI::pdat::SideData<double> &v_rhs,
SAMRAI::pdat::CellData<double> &p_resid,
SAMRAI::pdat::SideData<double> &v_resid,
SAMRAI::hier::Patch &patch,
const SAMRAI::hier::Box &pbox,
const SAMRAI::geom::CartesianPatchGeometry &geom)
{
boost::shared_ptr<SAMRAI::pdat::EdgeData<double> > edge_viscosity_ptr =
boost::dynamic_pointer_cast<SAMRAI::pdat::EdgeData<double> >
(patch.getPatchData(edge_viscosity_id));
SAMRAI::pdat::EdgeData<double> &edge_viscosity(*edge_viscosity_ptr);
const double *Dx = geom.getDx();
const SAMRAI::hier::Index ip(1,0,0), jp(0,1,0), kp(0,0,1);
const SAMRAI::hier::Index pp[]={ip,jp,kp};
SAMRAI::pdat::CellIterator cend(SAMRAI::pdat::CellGeometry::end(pbox));
for(SAMRAI::pdat::CellIterator ci(SAMRAI::pdat::CellGeometry::begin(pbox));
ci!=cend; ++ci)
{
const SAMRAI::pdat::CellIndex ¢er(*ci);
SAMRAI::pdat::CellIndex up(center), down(center), right(center),
left(center), front(center), back(center);
++right[0];
--left[0];
++up[1];
--down[1];
++front[2];
--back[2];
/* p */
if(center[0]!=pbox.upper(0) && center[1]!=pbox.upper(1)
&& center[2]!=pbox.upper(2))
{
const SAMRAI::pdat::SideIndex
x(center,0,SAMRAI::pdat::SideIndex::Lower),
y(center,1,SAMRAI::pdat::SideIndex::Lower),
z(center,2,SAMRAI::pdat::SideIndex::Lower);
double dvx_dx=(v(x+ip) - v(x))/Dx[0];
double dvy_dy=(v(y+jp) - v(y))/Dx[1];
double dvz_dz=(v(z+kp) - v(z))/Dx[2];
p_resid(center)=p_rhs(center) - dvx_dx - dvy_dy - dvz_dz;
}
for(Gamra::Dir ix=0;ix<3;++ix)
{
const Gamra::Dir iy(ix.next(3));
const Gamra::Dir iz(iy.next(3));
const SAMRAI::pdat::SideIndex
x(center,ix,SAMRAI::pdat::SideIndex::Lower),
y(center,iy,SAMRAI::pdat::SideIndex::Lower),
z(center,iz,SAMRAI::pdat::SideIndex::Lower);
const SAMRAI::pdat::EdgeIndex
edge_y(center,iy,SAMRAI::pdat::EdgeIndex::LowerLeft),
edge_z(center,iz,SAMRAI::pdat::EdgeIndex::LowerLeft);
if(center[iy]!=pbox.upper(iy) && center[iz]!=pbox.upper(iz))
{
if((center[ix]==pbox.lower(ix) && v(x-pp[ix])==boundary_value)
|| (center[ix]==pbox.upper(ix) && v(x+pp[ix])==boundary_value))
{
v_resid(x)=0;
}
else
{
v_resid(x)=v_rhs(x)
- v_operator_3D(v,p,cell_viscosity,edge_viscosity,
center,edge_y,edge_z,x,y,z,
pp[ix],pp[iy],pp[iz],Dx[ix],Dx[iy],Dx[iz]);
}
}
}
}
}
void
Elastic::FAC::pack_strain(double* buffer,
const SAMRAI::hier::Patch& patch,
const SAMRAI::hier::Box& region,
const int &depth) const
{
boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr=
boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(v_id));
SAMRAI::pdat::SideData<double>& v = *v_ptr;
boost::shared_ptr<SAMRAI::pdat::CellData<double> > dv_diagonal;
boost::shared_ptr<SAMRAI::pdat::SideData<double> > dv_mixed;
if(!faults.empty())
{
dv_diagonal=boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
(patch.getPatchData(dv_diagonal_id));
dv_mixed=boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(dv_mixed_id));
}
const Gamra::Dir dim=d_dim.getValue();
if(have_embedded_boundary())
{
boost::shared_ptr<SAMRAI::pdat::SideData<double> > level_set_ptr;
if(have_embedded_boundary())
level_set_ptr=boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(level_set_id));
}
Gamra::Dir ix(Gamra::Dir::from_int(depth/dim)),
iy(Gamra::Dir::from_int(depth%dim));
const SAMRAI::hier::Index zero(SAMRAI::hier::Index::getZeroIndex(d_dim));
SAMRAI::hier::Index ip(zero), jp(zero);
ip[ix]=1;
jp[iy]=1;
const double *dx(boost::dynamic_pointer_cast
<SAMRAI::geom::CartesianPatchGeometry>
(patch.getPatchGeometry())->getDx());
SAMRAI::pdat::CellIterator iend(SAMRAI::pdat::CellGeometry::end(region));
for(SAMRAI::pdat::CellIterator
icell(SAMRAI::pdat::CellGeometry::begin(region));
icell!=iend; ++icell)
{
const SAMRAI::pdat::SideIndex
s(*icell,ix,SAMRAI::pdat::SideIndex::Lower);
if(ix==iy)
{
double diff(v(s+ip)-v(s));
if(!faults.empty())
diff-=(*dv_diagonal)(*icell,ix);
*buffer=diff/dx[ix];
}
else
{
const int ix_iy(index_map(ix,iy,dim));
double diff(- v(s-jp) - v(s+ip-jp) + v(s+jp) + v(s+ip+jp));
if(!faults.empty())
diff+=(*dv_mixed)(s,ix_iy+1) - (*dv_mixed)(s-jp,ix_iy)
+ (*dv_mixed)(s+ip,ix_iy+1) - (*dv_mixed)(s+ip-jp,ix_iy)
+ (*dv_mixed)(s+jp,ix_iy+1) - (*dv_mixed)(s,ix_iy)
+ (*dv_mixed)(s+ip+jp,ix_iy+1) - (*dv_mixed)(s+ip,ix_iy);
*buffer=diff/(4*dx[iy]);
}
++buffer;
}
}
void Elastic::Boundary_Conditions::set_embedded_boundary
(const SAMRAI::hier::Patch& patch, const int &level_set_id,
const int &dv_mixed_id)
{
boost::shared_ptr<SAMRAI::pdat::SideData<double> > level_set_ptr=
boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
(patch.getPatchData(level_set_id));
SAMRAI::pdat::SideData<double> &level_set(*level_set_ptr);
boost::shared_ptr<SAMRAI::pdat::SideData<double> > dv_mixed_ptr;
if(dv_mixed_id!=invalid_id)
dv_mixed_ptr=boost::dynamic_pointer_cast
<SAMRAI::pdat::SideData<double> >(patch.getPatchData(dv_mixed_id));
const SAMRAI::tbox::Dimension dimension(patch.getDim());
const Gamra::Dir dim(dimension.getValue());
const SAMRAI::hier::Box gbox=level_set.getGhostBox();
const SAMRAI::hier::Box box=level_set.getBox();
boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
(patch.getPatchGeometry());
/* Corners are not synced, so we set the level set to a generic
* negative value and dv_mixed to zero. Setting dv_mixed to zero
* implies that we do not care about faults that intersect that
* corner (nor should we). */
for(Gamra::Dir ix=0; ix<dim; ++ix)
{
const Gamra::Dir iy(ix.next(dim));
const Gamra::Dir iz(iy.next(dim));
std::vector<std::vector<int> > corners(dim);
corners[ix].push_back(box.lower(ix));
corners[ix].push_back(box.upper(ix)+1);
if(geom->getTouchesRegularBoundary(iy,0))
corners[iy].push_back(gbox.lower(iy));
if(geom->getTouchesRegularBoundary(iy,1))
corners[iy].push_back(gbox.upper(iy));
if(dim==3)
{
if(geom->getTouchesRegularBoundary(iz,0))
corners[iz].push_back(gbox.lower(iz));
if(geom->getTouchesRegularBoundary(iz,1))
corners[iz].push_back(gbox.upper(iz));
}
SAMRAI::pdat::SideIndex x(SAMRAI::hier::Index(dimension),ix,
SAMRAI::pdat::SideIndex::Lower);
for(std::vector<int>::iterator i=corners[ix].begin();
i!=corners[ix].end(); ++i)
{
x[ix]=*i;
if(dim==2)
{
for(std::vector<int>::iterator j=corners[iy].begin();
j!=corners[iy].end();++j)
{
x[iy]=*j;
set_embedded_values(x,dim,level_set,dv_mixed_ptr);
}
}
else
{
for(std::vector<int>::iterator j=corners[iy].begin();
j!=corners[iy].end();++j)
for(int kk=gbox.lower(iz); kk<=gbox.upper(iz); ++kk)
{
x[iy]=*j;
x[iz]=kk;
set_embedded_values(x,dim,level_set,dv_mixed_ptr);
}
for(std::vector<int>::iterator k=corners[iz].begin();
k!=corners[iz].end();++k)
{
for(int jj=gbox.lower(iy); jj<=gbox.upper(iy); ++jj)
{
x[iy]=jj;
x[iz]=*k;
set_embedded_values(x,dim,level_set,dv_mixed_ptr);
}
}
}
}
}
}