void
SpongeLayerForceFunction::setDataOnPatchSide(
const int data_idx,
Pointer<Patch<NDIM> > patch)
{
Pointer<SideData<NDIM,double> > U_data = patch->getPatchData(d_u_var, d_u_ctx);
Pointer<SideData<NDIM,double> > F_data = patch->getPatchData(data_idx);
const Box<NDIM>& patch_box = patch->getBox();
Pointer<CartesianPatchGeometry<NDIM> > pgeom = patch->getPatchGeometry();
const double* const dx = pgeom->getDx();
blitz::TinyVector<int,NDIM> offset[2];
for (unsigned int side = 0; side <= 1; ++side)
{
for (unsigned int d = 0; d < NDIM; ++d)
{
offset[side][d] = static_cast<int>(d_width[side][d]/dx[d])-1;
}
}
const IntVector<NDIM>& ratio = pgeom->getRatio();
const Box<NDIM> domain_box = Box<NDIM>::refine(d_grid_geometry->getPhysicalDomain()[0],ratio);
const Index<NDIM>& domain_lower = domain_box.lower();
const Index<NDIM>& domain_upper = domain_box.upper();
for (unsigned int axis = 0; axis < NDIM; ++axis)
{
for (unsigned int side = 0; side <= 1; ++side)
{
if (!pgeom->getTouchesRegularBoundary(axis,side)) continue;
for (unsigned int component = 0; component < NDIM; ++component)
{
if (!d_forcing_enabled[side][axis][component]) continue;
Box<NDIM> bdry_box = domain_box;
if (side == 0)
{
bdry_box.upper()(axis) = domain_lower(axis)+(offset[side][axis] + (axis==component ? 1 : 0));
}
else
{
bdry_box.lower()(axis) = domain_upper(axis)-(offset[side][axis] + (axis==component ? 1 : 0));
}
for (Box<NDIM>::Iterator b(SideGeometry<NDIM>::toSideBox(bdry_box*patch_box,component)); b; b++)
{
const Index<NDIM>& i = b();
const SideIndex<NDIM> i_s(i, component, SideIndex<NDIM>::Lower);
(*F_data)(i_s) = d_kappa*(0.0 - (*U_data)(i_s));
}
}
}
}
return;
}// setDataOnPatchSide
int main(int argc, char **argv)
{
Kokkos::initialize();
try {
// Create random field
int M = 10;
Teuchos::ParameterList solverParams;
solverParams.set("Number of KL Terms", M);
solverParams.set("Mean", 1.0);
solverParams.set("Standard Deviation", 0.1);
int ndim = 3;
Teuchos::Array<double> domain_upper(ndim), domain_lower(ndim),
correlation_length(ndim);
for (int i=0; i<ndim; i++) {
domain_upper[i] = 1.0;
domain_lower[i] = 0.0;
correlation_length[i] = 10.0;
}
solverParams.set("Domain Upper Bounds", domain_upper);
solverParams.set("Domain Lower Bounds", domain_lower);
solverParams.set("Correlation Lengths", correlation_length);
Stokhos::KL::ExponentialRandomField<double> rf(solverParams);
rf.print(std::cout);
// Evaluate random field at a point
Teuchos::Array<double> x(ndim);
for (int i=0; i<ndim; i++)
x[i] = (domain_upper[i] + domain_lower[i])/2.0 +
0.1*(domain_upper[i] - domain_lower[i])/2.0;
Teuchos::Array<double> rvar(M);
for (int i=0; i<M; i++)
rvar[i] = 1.5;
double result = rf.evaluate(x, rvar);
std::cout << "result (host) = " << result << std::endl;
// Evaluate random field in a functor on device
typedef Kokkos::View<double*> view_type;
typedef view_type::HostMirror host_view_type;
view_type x_view("x", ndim);
host_view_type host_x = Kokkos::create_mirror_view(x_view);
for (int i=0; i<ndim; i++)
host_x(i) = x[i];
Kokkos::deep_copy(x_view, host_x);
view_type rvar_view("rvar", M);
host_view_type host_rvar = Kokkos::create_mirror_view(rvar_view);
for (int i=0; i<M; i++)
host_rvar(i) = rvar[i];
Kokkos::deep_copy(rvar_view, host_rvar);
RF<double> rf_func(rf, x_view, rvar_view);
host_view_type host_y = Kokkos::create_mirror_view(rf_func.y);
Kokkos::deep_copy(host_y, rf_func.y);
double result2 = host_y(0);
std::cout << "result (device)= " << result2 << std::endl;
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
Kokkos::finalize();
}
