int HGRAD_PYR_C1_FEM_Test01(const bool verbose) {
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (verbose)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
Teuchos::oblackholestream oldFormatState;
oldFormatState.copyfmt(std::cout);
typedef typename
Kokkos::Impl::is_space<DeviceSpaceType>::host_mirror_space::execution_space HostSpaceType ;
*outStream << "DeviceSpace:: "; DeviceSpaceType::print_configuration(*outStream, false);
*outStream << "HostSpace:: "; HostSpaceType::print_configuration(*outStream, false);
*outStream
<< "===============================================================================\n"
<< "| |\n"
<< "| Unit Test (Basis_HGRAD_PYR_C1_FEM) |\n"
<< "| |\n"
<< "| 1) Conversion of Dof tags into Dof ordinals and back |\n"
<< "| 2) Basis values for VALUE, GRAD, CURL, and Dk operators |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]), |\n"
<< "| Denis Ridzal ([email protected]), |\n"
<< "| Kara Peterson ([email protected]). |\n"
<< "| Kyungjoo Kim ([email protected]). |\n"
<< "| |\n"
<< "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n"
<< "| Trilinos website: http://trilinos.sandia.gov |\n"
<< "| |\n"
<< "===============================================================================\n";
typedef Kokkos::DynRankView<ValueType,DeviceSpaceType> DynRankView;
typedef Kokkos::DynRankView<ValueType,HostSpaceType> DynRankViewHost;
#define ConstructWithLabel(obj, ...) obj(#obj, __VA_ARGS__)
const ValueType tol = tolerence();
int errorFlag = 0;
// for virtual function, value and point types are declared in the class
typedef ValueType outputValueType;
typedef ValueType pointValueType;
Basis_HGRAD_PYR_C1_FEM<DeviceSpaceType,outputValueType,pointValueType> pyrBasis;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: constructors and exceptions |\n"
<< "===============================================================================\n";
try {
ordinal_type nthrow = 0, ncatch = 0;
#ifdef HAVE_INTREPID2_DEBUG
// Define array containing the 4 vertices of the reference PYR and its center.
DynRankView ConstructWithLabel(pyrNodes, 10, 3);
// Generic array for the output values; needs to be properly resized depending on the operator type
const auto numFields = pyrBasis.getCardinality();
const auto numPoints = pyrNodes.dimension(0);
const auto spaceDim = pyrBasis.getBaseCellTopology().getDimension();
DynRankView vals("vals", numFields, numPoints);
DynRankView vals_vec("vals", numFields, numPoints, spaceDim);
{
// exception #1: CURL cannot be applied to scalar functions
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(vals_vec, pyrNodes, OPERATOR_CURL) );
// exception #2: DIV cannot be applied to scalar functions
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(vals_vec, pyrNodes, OPERATOR_DIV) );
}
// Exceptions 3-7: all bf tags/bf Ids below are wrong and should cause getDofOrdinal() and
// getDofTag() to access invalid array elements thereby causing bounds check exception
{
// exception #3
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getDofOrdinal(3,0,0) );
// exception #4
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getDofOrdinal(1,1,1) );
// exception #5
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getDofOrdinal(0,6,0) );
// exception #6
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getDofTag(7) );
// exception #7
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getDofTag(-1) );
}
// Exceptions 8-18 test exception handling with incorrectly dimensioned input/output arrays
{
// exception #8: input points array must be of rank-2
DynRankView ConstructWithLabel(badPoints1, 4, 5, 3);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(vals, badPoints1, OPERATOR_VALUE) );
}
{
// exception #9 dimension 1 in the input point array must equal space dimension of the cell
DynRankView ConstructWithLabel(badPoints2, 4, 2);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(vals, badPoints2, OPERATOR_VALUE) );
}
{
// exception #10 output values must be of rank-2 for OPERATOR_VALUE
DynRankView ConstructWithLabel(badVals1, 4, 3, 1);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals1, pyrNodes, OPERATOR_VALUE) );
}
{
// exception #11 output values must be of rank-3 for OPERATOR_GRAD
DynRankView ConstructWithLabel(badVals2, 4, 3);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals2, pyrNodes, OPERATOR_GRAD) );
// exception #12 output values must be of rank-3 for OPERATOR_D1
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals2, pyrNodes, OPERATOR_D1) );
// exception #13 output values must be of rank-3 for OPERATOR_D2
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals2, pyrNodes, OPERATOR_D2) );
}
{
// exception #14 incorrect 0th dimension of output array (must equal number of basis functions)
DynRankView ConstructWithLabel(badVals3, numFields + 1, numPoints);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals3, pyrNodes, OPERATOR_VALUE) );
}
{
// exception #15 incorrect 1st dimension of output array (must equal number of points)
DynRankView ConstructWithLabel(badVals4, numFields, numPoints + 1);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals4, pyrNodes, OPERATOR_VALUE) );
}
{
// exception #16: incorrect 2nd dimension of output array (must equal the space dimension)
DynRankView ConstructWithLabel(badVals5, numFields, numPoints, 4);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals5, pyrNodes, OPERATOR_GRAD) );
}
{
// exception #17: incorrect 2nd dimension of output array (must equal D2 cardinality in 3D)
DynRankView ConstructWithLabel(badVals6, numFields, numPoints, 40);
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals6, pyrNodes, OPERATOR_D2) );
//exception #18: incorrect 2nd dimension of output array (must equal D3 cardinality in 3D)
INTREPID2_TEST_ERROR_EXPECTED( pyrBasis.getValues(badVals6, pyrNodes, OPERATOR_D3) );
}
#endif
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << nthrow << ")\n";
}
} catch (std::logic_error err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
}
*outStream \
<< "\n"
<< "===============================================================================\n" \
<< "| TEST 2: correctness of tag to enum and enum to tag lookups |\n" \
<< "===============================================================================\n";
try {
const auto numFields = pyrBasis.getCardinality();
const auto allTags = pyrBasis.getAllDofTags();
// Loop over all tags, lookup the associated dof enumeration and then lookup the tag again
const auto dofTagSize = allTags.dimension(0);
for (auto i=0;i<dofTagSize;++i) {
const auto bfOrd = pyrBasis.getDofOrdinal(allTags(i,0), allTags(i,1), allTags(i,2));
const auto myTag = pyrBasis.getDofTag(bfOrd);
if( !( (myTag(0) == allTags(i,0)) &&
(myTag(1) == allTags(i,1)) &&
(myTag(2) == allTags(i,2)) &&
(myTag(3) == allTags(i,3)) ) ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofOrdinal( {"
<< allTags(i,0) << ", "
<< allTags(i,1) << ", "
<< allTags(i,2) << ", "
<< allTags(i,3) << "}) = " << bfOrd <<" but \n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "}\n";
}
}
// Now do the same but loop over basis functions
for (auto bfOrd=0;bfOrd<numFields;++bfOrd) {
const auto myTag = pyrBasis.getDofTag(bfOrd);
const auto myBfOrd = pyrBasis.getDofOrdinal(myTag(0), myTag(1), myTag(2));
if( bfOrd != myBfOrd) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} but getDofOrdinal({"
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} ) = " << myBfOrd << "\n";
}
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
}
*outStream \
<< "\n"
<< "===============================================================================\n" \
<< "| TEST 3: correctness of basis function values |\n" \
<< "===============================================================================\n";
outStream -> precision(20);
// VALUE: Each row gives the 4 correct basis set values at an evaluation point
const ValueType basisValues[] = {
1.0, 0.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 0.0, 1.0,
//
0.0515625, 0.0984375, 0.4265625, 0.2234375, 0.2,
0.2, 0, 0., 0.5, 0.3,
0.025, 0.025, 0., 0, 0.95,
0.18, 0.045, 0.005, 0.02, 0.75,
0.035, 0.015, 0.285, 0.665, 0.,
};
// GRAD and D1: each row gives the 3 x 5 correct values of the gradients of the 5 basis functions
const ValueType basisGrads[] = {
-0.5, -0.5, 0.0, 0.5, 0.0, -0.5, 0.0, 0.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, \
-0.5, 0.0, -0.5, 0.5, -0.5, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, \
0.0, 0.0, 0.0, 0.0, -0.5, -0.5, 0.5, 0.5, 0.0, -0.5, 0.0, -0.5, 0.0, 0.0, 1.0, \
0.0, -0.5, -0.5, 0.0, 0.0, 0.0, 0.5, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.0, 1.0, \
-0.25,-0.25,-0.25, 0.25,-0.25,-0.25, 0.25, 0.25,-0.25,-0.25, 0.25,-0.25, 0.0, 0.0, 1.0, \
-0.09375, -0.171875, -0.201171875, 0.09375, -0.328125, -0.298828125, 0.40625, 0.328125, -0.201171875, -0.40625, 0.171875, -0.298828125, 0.0, 0.0, 1.0, \
-0.1428571428571429, -0.5, -0.3571428571428571, 0.1428571428571429, 0.0, -0.1428571428571429, 0.3571428571428571, 0.0, -0.3571428571428571, -0.3571428571428571, 0.5, -0.1428571428571429, 0.0, 0.0, 1.0, \
-0.5, -0.25, -0.25, 0.5, -0.25, -0.25, 0.0, 0.25, -0.25, 0., 0.25, -0.25, 0.0, 0.0, 1.0, \
-0.45, -0.4, -0.13, 0.45, -0.1, -0.37, 0.05, 0.1, -0.13, -0.05, 0.4, -0.37, 0.0, 0.0, 1.0, \
-0.025, -0.35, -0.34, 0.025, -0.15, -0.16, 0.475, 0.15, -0.34, -0.475, 0.35, -0.16, 0.0, 0.0, 1.0
};
//D2: flat array with the values of D2 applied to basis functions. Multi-index is (P,F,K)
const auto eps = epsilon();
const ValueType basisD2[] = {
0, 0.25,-0.25, 0,-0.25, 0.5, 0,-0.25, 0.25, 0, 0.25,-0.5, 0, 0.25,-0.25, 0,-0.25, 0.5, 0,-0.25, 0.25, 0, 0.25,-0.5, 0, 0, 0, 0, 0, 0, \
0, 0.25,-0.25, 0, 0.25,-0.5, 0,-0.25, 0.25, 0,-0.25, 0.5, 0, 0.25,-0.25, 0, 0.25,-0.5, 0,-0.25, 0.25, 0,-0.25, 0.5, 0, 0, 0, 0, 0, 0, \
0, 0.25, 0.25, 0, 0.25, 0.5, 0,-0.25,-0.25, 0,-0.25,-0.5, 0, 0.25, 0.25, 0, 0.25, 0.5, 0,-0.25,-0.25, 0,-0.25,-0.5, 0, 0, 0, 0, 0, 0, \
0, 0.25, 0.25, 0,-0.25,-0.5, 0,-0.25,-0.25, 0, 0.25, 0.5, 0, 0.25, 0.25, 0,-0.25,-0.5, 0,-0.25,-0.25, 0, 0.25, 0.5, 0, 0, 0, 0, 0, 0, \
0, 0.25/eps, 0, 0, 0, 0, 0,-0.25/eps, 0, 0, 0, 0, 0, 0.25/eps, 0, 0, 0, 0, 0,-0.25/eps, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, \
0, 0.3125, 0.1953125, 0, 0.09765625, 0.1220703125, 0,-0.3125,-0.1953125, 0,-0.09765625,-0.1220703125, 0, 0.3125, 0.1953125, 0, 0.09765625, 0.1220703125, 0,-0.3125,-0.1953125, 0,-0.09765625,-0.1220703125, 0, 0, 0, 0, 0, 0, \
0, 0.3571428571428571, 0.1530612244897959, 0,-0.3571428571428571,-0.306122448979592, 0,-0.3571428571428572,-0.1530612244897959, 0, 0.3571428571428571, 0.306122448979592, 0, 0.3571428571428571, 0.1530612244897959, 0,-0.3571428571428571,-0.306122448979592, 0,-0.3571428571428571,-0.1530612244897959, 0, 0.3571428571428571, 0.306122448979592, 0, 0, 0, 0, 0, 0, \
0, 5,-5, 0, 0, 0, 0,-5, 5, 0, 0, 0, 0, 5,-5, 0, 0, 0, 0, -5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 1,-0.8, 0,-0.6, 0.96, 0, -1, 0.8, 0, 0.6,-0.96, 0,1,-0.8, 0, -0.6, 0.96, 0, -1, 0.8, 0, 0.6, -0.96, 0, 0, 0, 0, 0, 0, \
0, 0.25, 0.225, 0,-0.1,-0.18, 0,-0.25,-0.225, 0, 0.1, 0.18, 0, 0.25, 0.225, 0,-0.1,-0.18, 0,-0.25,-0.225,0,0.1,0.18, 0, 0, 0, 0, 0, 0
};
try {
DynRankViewHost ConstructWithLabel(pyrNodesHost, 10, 3);
pyrNodesHost(0,0) = -1.0; pyrNodesHost(0,1) = -1.0; pyrNodesHost(0,2) = 0;
pyrNodesHost(1,0) = 1.0; pyrNodesHost(1,1) = -1.0; pyrNodesHost(1,2) = 0;
pyrNodesHost(2,0) = 1.0; pyrNodesHost(2,1) = 1.0; pyrNodesHost(2,2) = 0;
pyrNodesHost(3,0) = -1.0; pyrNodesHost(3,1) = 1.0; pyrNodesHost(3,2) = 0;
pyrNodesHost(4,0) = 0.0; pyrNodesHost(4,1) = 0.0; pyrNodesHost(4,2) = 1.0;
pyrNodesHost(5,0) = 0.25; pyrNodesHost(5,1) = 0.5; pyrNodesHost(5,2) = 0.2;
pyrNodesHost(6,0) = -0.7 ; pyrNodesHost(6,1) = 0.3; pyrNodesHost(6,2) = 0.3;
pyrNodesHost(7,0) = 0.; pyrNodesHost(7,1) = -0.05; pyrNodesHost(7,2) = 0.95;
pyrNodesHost(8,0) = -0.15; pyrNodesHost(8,1) = -0.2; pyrNodesHost(8,2) = 0.75;
pyrNodesHost(9,0) = -0.4; pyrNodesHost(9,1) = 0.9; pyrNodesHost(9,2) = 0.0;
auto pyrNodes = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), pyrNodesHost);
Kokkos::deep_copy(pyrNodes, pyrNodesHost);
// Dimensions for the output arrays:
const auto numFields = pyrBasis.getCardinality();
const auto numPoints = pyrNodes.dimension(0);
const auto spaceDim = pyrBasis.getBaseCellTopology().getDimension();
const auto D2Cardin = getDkCardinality(OPERATOR_D2, spaceDim);
// Check VALUE of basis functions: resize vals to rank-2 container:
{
DynRankView vals = DynRankView("vals", numFields, numPoints);
pyrBasis.getValues(vals, pyrNodes, OPERATOR_VALUE);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (auto i=0;i<numFields;++i) {
for (auto j=0;j<numPoints;++j) {
const auto l = i + j * numFields;
if (std::abs(vals_host(i,j) - basisValues[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";
*outStream << "} computed value: " << vals_host(i,j)
<< " but reference value: " << basisValues[l] << "\n";
}
}
}
}
// Check GRAD of basis function: resize vals to rank-3 container
{
DynRankView vals = DynRankView("vals", numFields, numPoints, spaceDim);
pyrBasis.getValues(vals, pyrNodes, OPERATOR_GRAD);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (auto i=0;i<numFields;++i) {
for (auto j=0;j<numPoints;++j) {
for (auto k=0;k<spaceDim;++k) {
const auto l = k + i * spaceDim + j * spaceDim * numFields;
if (std::abs(vals_host(i,j,k) - basisGrads[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed grad component: " << vals_host(i,j,k)
<< " but reference grad component: " << basisGrads[l] << "\n";
}
}
}
}
}
// Check D1 of basis function
{
DynRankView vals = DynRankView("vals", numFields, numPoints, spaceDim);
pyrBasis.getValues(vals, pyrNodes, OPERATOR_D1);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (auto i=0;i<numFields;++i) {
for (auto j=0;j<numPoints;++j) {
for (auto k=0;k<spaceDim;++k) {
const auto l = k + i * spaceDim + j * spaceDim * numFields;
if (std::abs(vals_host(i,j,k) - basisGrads[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D1 component: " << vals_host(i,j,k)
<< " but reference D1 component: " << basisGrads[l] << "\n";
}
}
}
}
}
// Check D2 of basis function
{
DynRankView vals = DynRankView("vals", numFields, numPoints, D2Cardin);
pyrBasis.getValues(vals, pyrNodes, OPERATOR_D2);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (auto i=0;i<numFields;++i) {
for (auto j=0;j<numPoints;++j) {
// derivatives are singular when z = 1; using the same eps, it can be comparable
//if (j == 4) continue;
for (auto k=0;k<D2Cardin;++k) {
const auto l = k + i * D2Cardin + j * D2Cardin * numFields;
if (std::abs(vals_host(i,j,k) - basisD2[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D2 component: " << vals_host(i,j,k)
<< " but reference D2 component: " << basisD2[l] << "\n";
}
}
}
}
}
// Check all higher derivatives - must be zero.
{
const EOperator ops[] = { OPERATOR_D3,
OPERATOR_D4,
OPERATOR_D5,
OPERATOR_D6,
OPERATOR_D7,
OPERATOR_D8,
OPERATOR_D9,
OPERATOR_D10,
OPERATOR_MAX };
for (auto h=0;ops[h]!=OPERATOR_MAX;++h) {
const auto op = ops[h];
const auto DkCardin = getDkCardinality(op, spaceDim);
DynRankView vals("vals", numFields, numPoints, DkCardin);
pyrBasis.getValues(vals, pyrNodes, op);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (auto i1=0;i1<numFields; i1++)
for (auto i2=0;i2<numPoints; i2++)
for (auto i3=0;i3<DkCardin; i3++) {
if (std::abs(vals_host(i1,i2,i3)) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Get the multi-index of the value where the error is and the operator order
const auto ord = Intrepid2::getOperatorOrder(op);
*outStream << " At multi-index { "<<i1<<" "<<i2 <<" "<<i3;
*outStream << "} computed D"<< ord <<" component: " << vals(i1,i2,i3)
<< " but reference D" << ord << " component: 0 \n";
}
}
}
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
}
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
// reset format state of std::cout
std::cout.copyfmt(oldFormatState);
return errorFlag;
}
int HCURL_WEDGE_I1_FEM_Test01(const bool verbose) {
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (verbose)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
Teuchos::oblackholestream oldFormatState;
oldFormatState.copyfmt(std::cout);
typedef typename
Kokkos::Impl::is_space<DeviceSpaceType>::host_mirror_space::execution_space HostSpaceType ;
*outStream << "DeviceSpace:: "; DeviceSpaceType::print_configuration(*outStream, false);
*outStream << "HostSpace:: "; HostSpaceType::print_configuration(*outStream, false);
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| |\n"
<< "| Unit Test (Basis_HCURL_WEDGE_I1_FEM) |\n"
<< "| |\n"
<< "| 1) Conversion of Dof tags into Dof ordinals and back |\n"
<< "| 2) Basis values for VALUE and CURL operators |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]), |\n"
<< "| Denis Ridzal ([email protected]), |\n"
<< "| Kara Peterson ([email protected]). |\n"
<< "| Kyungjoo Kim ([email protected]). |\n"
<< "| |\n"
<< "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n"
<< "| Trilinos website: http://trilinos.sandia.gov |\n"
<< "| |\n"
<< "===============================================================================\n";
typedef Kokkos::DynRankView<ValueType,DeviceSpaceType> DynRankView;
typedef Kokkos::DynRankView<ValueType,HostSpaceType> DynRankViewHost;
#define ConstructWithLabel(obj, ...) obj(#obj, __VA_ARGS__)
const ValueType tol = tolerence();
int errorFlag = 0;
// for virtual function, value and point types are declared in the class
typedef ValueType outputValueType;
typedef ValueType pointValueType;
Basis_HCURL_WEDGE_I1_FEM<DeviceSpaceType,outputValueType,pointValueType> wedgeBasis;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: Basis creation, exception testing |\n"
<< "===============================================================================\n";
try{
ordinal_type nthrow = 0, ncatch = 0;
#ifdef HAVE_INTREPID2_DEBUG
// Define array containing the 4 vertices of the reference WEDGE and its center.
DynRankView ConstructWithLabel(wedgeNodes, 12, 3);
// Generic array for the output values; needs to be properly resized depending on the operator type
const ordinal_type numFields = wedgeBasis.getCardinality();
const ordinal_type numPoints = wedgeNodes.dimension(0);
const ordinal_type spaceDim = wedgeBasis.getBaseCellTopology().getDimension();
DynRankView vals ("vals", numFields, numPoints);
DynRankView vals_vec ("vals", numFields, numPoints, spaceDim);
{
// exception #1: GRAD cannot be applied to HCURL functions
// resize vals to rank-3 container with dimensions (num. basis functions, num. points, arbitrary)
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals_vec, wedgeNodes, OPERATOR_GRAD) );
// exception #2: DIV cannot be applied to HCURL functions
// resize vals to rank-2 container with dimensions (num. basis functions, num. points)
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_DIV) );
}
// Exceptions 3-7: all bf tags/bf Ids below are wrong and should cause getDofOrdinal() and
// getDofTag() to access invalid array elements thereby causing bounds check exception
{
// exception #3
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(3,0,0) );
// exception #4
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(1,1,1) );
// exception #5
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(0,4,1) );
// exception #6
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofTag(numFields) );
// exception #7
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofTag(-1) );
}
// Exceptions 8- test exception handling with incorrectly dimensioned input/output arrays
{
// exception #8: input points array must be of rank-2
DynRankView ConstructWithLabel(badPoints1, 4, 5, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals, badPoints1, OPERATOR_VALUE) );
}
{
// exception #9 dimension 1 in the input point array must equal space dimension of the cell
DynRankView ConstructWithLabel(badPoints2, 4, 2);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals, badPoints2, OPERATOR_VALUE) );
}
{
// exception #10 output values must be of rank-3 for OPERATOR_VALUE
DynRankView ConstructWithLabel(badVals1, 4, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals1, wedgeNodes, OPERATOR_VALUE) );
// exception #11 output values must be of rank-3 for OPERATOR_CURL
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals1, wedgeNodes, OPERATOR_CURL) );
}
{
// exception #12 incorrect 0th dimension of output array (must equal number of basis functions)
DynRankView ConstructWithLabel(badVals2, numFields + 1, numPoints, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals2, wedgeNodes, OPERATOR_VALUE) );
}
{
// exception #13 incorrect 1st dimension of output array (must equal number of points)
DynRankView ConstructWithLabel(badVals3, numFields, numPoints + 1, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals3, wedgeNodes, OPERATOR_VALUE) );
}
{
// exception #14: incorrect 2nd dimension of output array (must equal the space dimension)
DynRankView ConstructWithLabel(badVals4, numFields, numPoints, 4);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals4, wedgeNodes, OPERATOR_VALUE) );
// exception #15: incorrect 2nd dimension of output array (must equal the space dimension)
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals4, wedgeNodes, OPERATOR_CURL) );
}
#endif
// Check if number of thrown exceptions matches the one we expect
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << nthrow << ")\n";
}
} catch (std::logic_error err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 2: correctness of tag to enum and enum to tag lookups |\n"
<< "===============================================================================\n";
try{
const ordinal_type numFields = wedgeBasis.getCardinality();
const auto allTags = wedgeBasis.getAllDofTags();
// Loop over all tags, lookup the associated dof enumeration and then lookup the tag again
const ordinal_type dofTagSize = allTags.dimension(0);
for (ordinal_type i = 0; i < dofTagSize; ++i) {
auto bfOrd = wedgeBasis.getDofOrdinal(allTags(i,0), allTags(i,1), allTags(i,2));
const auto myTag = wedgeBasis.getDofTag(bfOrd);
if( !( (myTag(0) == allTags(i,0)) &&
(myTag(1) == allTags(i,1)) &&
(myTag(2) == allTags(i,2)) &&
(myTag(3) == allTags(i,3)) ) ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofOrdinal( {"
<< allTags(i,0) << ", "
<< allTags(i,1) << ", "
<< allTags(i,2) << ", "
<< allTags(i,3) << "}) = " << bfOrd <<" but \n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "}\n";
}
}
// Now do the same but loop over basis functions
for( ordinal_type bfOrd = 0; bfOrd < numFields; ++bfOrd) {
const auto myTag = wedgeBasis.getDofTag(bfOrd);
const auto myBfOrd = wedgeBasis.getDofOrdinal(myTag(0), myTag(1), myTag(2));
if( bfOrd != myBfOrd) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} but getDofOrdinal({"
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} ) = " << myBfOrd << "\n";
}
}
} catch (std::logic_error err){
*outStream << err.what() << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 3: correctness of basis function values |\n"
<< "===============================================================================\n";
outStream -> precision(20);
// VALUE: Each row pair gives the 9x3 correct basis set values at an evaluation point: (P,F,D) layout
const ValueType basisValues[] = {
1.00000, 0, 0, 0, 0, 0, 0, -1.00000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0.500000, 0, 0, 0, 0, 0, 0, 1.00000, 1.00000, 0, 0, 1.00000, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.500000, 0, 0, 0, 0, \
0, 0, -1.00000, 0, 0, -1.00000, -1.00000, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0.500000, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1.00000, 0, 0, 0, 0, 0, 0, -1.00000, 0, 0, 0, 0.500000, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00000, 1.00000, 0, 0, 1.00000, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0.500000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, -1.00000, 0, 0, -1.00000, -1.00000, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0.500000, 0.500000, 0.250000, 0, -0.500000, 0.250000, 0, \
-0.500000, -0.750000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.125000, \
0, 0, 0.125000, 0, 0, 0.250000, 0.375000, 0.250000, 0, -0.125000, \
0.250000, 0, -0.125000, -0.250000, 0, 0.375000, 0.250000, 0, \
-0.125000, 0.250000, 0, -0.125000, -0.250000, 0, 0, 0, 0.125000, 0, \
0, 0.250000, 0, 0, 0.125000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.750000, \
0.250000, 0, -0.250000, 0.250000, 0, -0.250000, -0.750000, 0, 0, 0, \
0.250000, 0, 0, 0.125000, 0, 0, 0.125000, 0.125000, 0.0312500, 0, 0, \
0.0312500, 0, 0, -0.0937500, 0, 0.875000, 0.218750, 0, 0, 0.218750, \
0, 0, -0.656250, 0, 0, 0, 0.375000, 0, 0, 0.125000, 0, 0, 0, \
0.312500, 0, 0, -0.312500, 0, 0, -0.312500, -0.625000, 0, 0.187500, \
0, 0, -0.187500, 0, 0, -0.187500, -0.375000, 0, 0, 0, 0.250000, 0, 0, \
0, 0, 0, 0.250000, 0.250000, 0.250000, 0, -0.250000, 0.250000, 0, \
-0.250000, -0.250000, 0, 0.250000, 0.250000, 0, -0.250000, 0.250000, \
0, -0.250000, -0.250000, 0, 0, 0, 0, 0, 0, 0.250000, 0, 0, 0.250000
};
// CURL: each row pair gives the 9x3 correct values of the curls of the 9 basis functions: (P,F,D) layout
const ValueType basisCurls[] = {
0, -0.500000, 2.00000, 0, 0, 2.00000, -0.500000, 0, 2.00000, 0, \
0.500000, 0, 0, 0, 0, 0.500000, 0, 0, -0.500000, 0.500000, 0, 0, \
-0.500000, 0, 0.500000, 0, 0, 0.500000, -0.500000, 2.00000, 0.500000, \
0, 2.00000, 0, 0, 2.00000, -0.500000, 0.500000, 0, -0.500000, 0, 0, \
0, 0, 0, -0.500000, 0.500000, 0, 0, -0.500000, 0, 0.500000, 0, 0, 0, \
0, 2.00000, 0, 0.500000, 2.00000, -0.500000, 0.500000, 2.00000, 0, 0, \
0, 0, -0.500000, 0, 0.500000, -0.500000, 0, -0.500000, 0.500000, 0, \
0, -0.500000, 0, 0.500000, 0, 0, 0, -0.500000, 0, 0, 0, 0, -0.500000, \
0, 0, 0, 0.500000, 2.00000, 0, 0, 2.00000, 0.500000, 0, 2.00000, \
-0.500000, 0.500000, 0, 0, -0.500000, 0, 0.500000, 0, 0, 0.500000, \
-0.500000, 0, 0.500000, 0, 0, 0, 0, 0, -0.500000, 0.500000, 2.00000, \
-0.500000, 0, 2.00000, 0, 0, 2.00000, -0.500000, 0.500000, 0, 0, \
-0.500000, 0, 0.500000, 0, 0, 0, 0, 0, 0, 0.500000, 0, -0.500000, \
0.500000, 0, 0, 0, 2.00000, 0, -0.500000, 2.00000, 0.500000, \
-0.500000, 2.00000, -0.500000, 0.500000, 0, 0, -0.500000, 0, \
0.500000, 0, 0, 0.125000, -0.250000, 2.00000, 0.125000, 0.250000, \
2.00000, -0.375000, 0.250000, 2.00000, -0.125000, 0.250000, 0, \
-0.125000, -0.250000, 0, 0.375000, -0.250000, 0, -0.500000, 0.500000, \
0, 0, -0.500000, 0, 0.500000, 0, 0, 0.250000, -0.375000, 1.00000, \
0.250000, 0.125000, 1.00000, -0.250000, 0.125000, 1.00000, -0.250000, \
0.375000, 1.00000, -0.250000, -0.125000, 1.00000, 0.250000, \
-0.125000, 1.00000, -0.500000, 0.500000, 0, 0, -0.500000, 0, \
0.500000, 0, 0, 0.125000, -0.375000, 0, 0.125000, 0.125000, 0, \
-0.375000, 0.125000, 0, -0.125000, 0.375000, 2.00000, -0.125000, \
-0.125000, 2.00000, 0.375000, -0.125000, 2.00000, -0.500000, \
0.500000, 0, 0, -0.500000, 0, 0.500000, 0, 0, 0.125000, -0.500000, \
0.250000, 0.125000, 0, 0.250000, -0.375000, 0, 0.250000, -0.125000, \
0.500000, 1.75000, -0.125000, 0, 1.75000, 0.375000, 0, 1.75000, \
-0.500000, 0.500000, 0, 0, -0.500000, 0, 0.500000, 0, 0, 0, \
-0.250000, 1.25000, 0, 0.250000, 1.25000, -0.500000, 0.250000, \
1.25000, 0, 0.250000, 0.750000, 0, -0.250000, 0.750000, 0.500000, \
-0.250000, 0.750000, -0.500000, 0.500000, 0, 0, -0.500000, 0, \
0.500000, 0, 0, 0.250000, -0.250000, 1.00000, 0.250000, 0.250000, \
1.00000, -0.250000, 0.250000, 1.00000, -0.250000, 0.250000, 1.00000, \
-0.250000, -0.250000, 1.00000, 0.250000, -0.250000, 1.00000, \
-0.500000, 0.500000, 0, 0, -0.500000, 0, 0.500000, 0, 0
};
try{
DynRankViewHost ConstructWithLabel(wedgeNodesHost, 12, 3);
wedgeNodesHost(0,0) = 0.0; wedgeNodesHost(0,1) = 0.0; wedgeNodesHost(0,2) = -1.0;
wedgeNodesHost(1,0) = 1.0; wedgeNodesHost(1,1) = 0.0; wedgeNodesHost(1,2) = -1.0;
wedgeNodesHost(2,0) = 0.0; wedgeNodesHost(2,1) = 1.0; wedgeNodesHost(2,2) = -1.0;
wedgeNodesHost(3,0) = 0.0; wedgeNodesHost(3,1) = 0.0; wedgeNodesHost(3,2) = 1.0;
wedgeNodesHost(4,0) = 1.0; wedgeNodesHost(4,1) = 0.0; wedgeNodesHost(4,2) = 1.0;
wedgeNodesHost(5,0) = 0.0; wedgeNodesHost(5,1) = 1.0; wedgeNodesHost(5,2) = 1.0;
wedgeNodesHost(6,0) = 0.25; wedgeNodesHost(6,1) = 0.5; wedgeNodesHost(6,2) = -1.0;
wedgeNodesHost(7,0) = 0.5; wedgeNodesHost(7,1) = 0.25; wedgeNodesHost(7,2) = 0.0;
wedgeNodesHost(8,0) = 0.25; wedgeNodesHost(8,1) = 0.25; wedgeNodesHost(8,2) = 1.0;
wedgeNodesHost(9,0) = 0.25; wedgeNodesHost(9,1) = 0.0; wedgeNodesHost(9,2) = 0.75;
wedgeNodesHost(10,0)= 0.0; wedgeNodesHost(10,1)= 0.5; wedgeNodesHost(10,2)= -0.25;
wedgeNodesHost(11,0)= 0.5; wedgeNodesHost(11,1)= 0.5; wedgeNodesHost(11,2)= 0.0;
const auto wedgeNodes = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), wedgeNodesHost);
Kokkos::deep_copy(wedgeNodes, wedgeNodesHost);
// Dimensions for the output arrays:
const ordinal_type numFields = wedgeBasis.getCardinality();
const ordinal_type numPoints = wedgeNodes.dimension(0);
const ordinal_type spaceDim = wedgeBasis.getBaseCellTopology().getDimension();
{
// Check VALUE of basis functions: resize vals to rank-3 container:
DynRankView ConstructWithLabel(vals, numFields, numPoints, spaceDim);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_VALUE);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < spaceDim; ++k) {
// compute offset for (P,F,D) data layout: indices are P->j, F->i, D->k
const ordinal_type l = k + i * spaceDim + j * spaceDim * numFields;
if (std::abs(vals_host(i,j,k) - basisValues[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed value: " << vals_host(i,j,k)
<< " but reference value: " << basisValues[l] << "\n";
}
}
}
}
}
{
// Check CURL of basis function: resize vals to rank-3 container
DynRankView ConstructWithLabel(vals, numFields, numPoints, spaceDim);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_CURL);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < spaceDim; ++k) {
// compute offset for (P,F,D) data layout: indices are P->j, F->i, D->k
const ordinal_type l = k + i * spaceDim + j * spaceDim * numFields;
if (std::abs(vals_host(i,j,k) - basisCurls[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed curl component: " << vals_host(i,j,k)
<< " but reference curl component: " << basisCurls[l] << "\n";
}
}
}
}
}
}
// Catch unexpected errors
catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
};
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
// reset format state of std::cout
std::cout.copyfmt(oldFormatState);
return errorFlag;
}
int HGRAD_WEDGE_C2_FEM_Test01(const bool verbose) {
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (verbose)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
Teuchos::oblackholestream oldFormatState;
oldFormatState.copyfmt(std::cout);
typedef typename
Kokkos::Impl::is_space<DeviceSpaceType>::host_mirror_space::execution_space HostSpaceType ;
*outStream << "DeviceSpace:: "; DeviceSpaceType::print_configuration(*outStream, false);
*outStream << "HostSpace:: "; HostSpaceType::print_configuration(*outStream, false);
*outStream
<< "===============================================================================\n"
<< "| |\n"
<< "| Unit Test (Basis_HGRAD_WEDGE_C2_FEM) |\n"
<< "| |\n"
<< "| 1) Conversion of Dof tags into Dof ordinals and back |\n"
<< "| 2) Basis values for VALUE, GRAD, and Dk operators |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]), |\n"
<< "| Denis Ridzal ([email protected]), |\n"
<< "| Kara Peterson ([email protected]), |\n"
<< "| Kyungjoo Kim ([email protected]). |\n"
<< "| |\n"
<< "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n"
<< "| Trilinos website: http://trilinos.sandia.gov |\n"
<< "| |\n"
<< "===============================================================================\n";
typedef Kokkos::DynRankView<ValueType,DeviceSpaceType> DynRankView;
typedef Kokkos::DynRankView<ValueType,HostSpaceType> DynRankViewHost;
#define ConstructWithLabel(obj, ...) obj(#obj, __VA_ARGS__)
const ValueType tol = tolerence();
int errorFlag = 0;
// for virtual function, value and point types are declared in the class
typedef ValueType outputValueType;
typedef ValueType pointValueType;
Basis_HGRAD_WEDGE_C2_FEM<DeviceSpaceType,outputValueType,pointValueType> wedgeBasis;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: constructors and exceptions |\n"
<< "===============================================================================\n";
try {
ordinal_type nthrow = 0, ncatch = 0;
#ifdef HAVE_INTREPID2_DEBUG
// Define array containing the 4 vertices of the reference WEDGE and its center.
DynRankView ConstructWithLabel(wedgeNodes, 18, 3);
// Generic array for the output values; needs to be properly resized depending on the operator type
const ordinal_type numFields = wedgeBasis.getCardinality();
const ordinal_type numPoints = wedgeNodes.extent(0);
const ordinal_type spaceDim = wedgeBasis.getBaseCellTopology().getDimension();
DynRankView vals("vals", numFields, numPoints);
DynRankView vals_vec("vals", numFields, numPoints, spaceDim);
{
// exception #1: CURL cannot be applied to scalar functions
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals_vec, wedgeNodes, OPERATOR_DIV) );
// exception #2: DIV cannot be applied to scalar functions
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals_vec, wedgeNodes, OPERATOR_DIV) );
}
// Exceptions 3-7: all bf tags/bf Ids below are wrong and should cause getDofOrdinal() and
// getDofTag() to access invalid array elements thereby causing bounds check exception
{
// exception #3
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(3,0,0) );
// exception #4
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(1,1,1) );
// exception #5
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofOrdinal(0,9,0) );
// exception #6
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofTag(numFields) );
// exception #7
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getDofTag(-1) );
}
// Exceptions 8-18 test exception handling with incorrectly dimensioned input/output arrays
{
// exception #8: input points array must be of rank-2
DynRankView ConstructWithLabel( badPoints1, 4, 5, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals, badPoints1, OPERATOR_VALUE) );
}
{
// exception #9 dimension 1 in the input point array must equal space dimension of the cell
DynRankView ConstructWithLabel( badPoints2, 4, spaceDim + 1);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(vals, badPoints2, OPERATOR_VALUE) );
}
{
// exception #10 output values must be of rank-2 for OPERATOR_VALUE
DynRankView ConstructWithLabel( badVals1, 4, 3, 1);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals1, wedgeNodes, OPERATOR_VALUE) );
}
{
// exception #11 output values must be of rank-3 for OPERATOR_GRAD
DynRankView ConstructWithLabel( badVals2, 4, 3);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals2, wedgeNodes, OPERATOR_GRAD) );
// exception #12 output values must be of rank-3 for OPERATOR_D1
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals2, wedgeNodes, OPERATOR_D1) );
// exception #13 output values must be of rank-3 for OPERATOR_D2
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals2, wedgeNodes, OPERATOR_D2) );
}
{
// exception #14 incorrect 0th dimension of output array (must equal number of basis functions)
DynRankView ConstructWithLabel( badVals3, numFields + 1, numPoints);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals3, wedgeNodes, OPERATOR_VALUE) );
}
{
// exception #15 incorrect 1st dimension of output array (must equal number of points)
DynRankView ConstructWithLabel( badVals4, numFields, numPoints + 1);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals4, wedgeNodes, OPERATOR_VALUE) );
}
{
// exception #16: incorrect 2nd dimension of output array (must equal the space dimension)
DynRankView ConstructWithLabel( badVals5, numFields, numPoints, spaceDim - 1);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals5, wedgeNodes, OPERATOR_GRAD) );
}
{
// exception #17: incorrect 2nd dimension of output array (must equal D2 cardinality in 3D)
DynRankView ConstructWithLabel( badVals6, numFields, numPoints, 40);
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals6, wedgeNodes, OPERATOR_D2) );
// exception #18: incorrect 2nd dimension of output array (must equal D3 cardinality in 3D)
INTREPID2_TEST_ERROR_EXPECTED( wedgeBasis.getValues(badVals6, wedgeNodes, OPERATOR_D3) );
}
#endif
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << ncatch << ")\n";
}
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
}
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 2: correctness of tag to enum and enum to tag lookups |\n"
<< "===============================================================================\n";
try {
const ordinal_type numFields = wedgeBasis.getCardinality();
const auto allTags = wedgeBasis.getAllDofTags();
// Loop over all tags, lookup the associated dof enumeration and then lookup the tag again
const ordinal_type dofTagSize = allTags.extent(0);
for (ordinal_type i=0;i<dofTagSize;++i) {
const auto bfOrd = wedgeBasis.getDofOrdinal(allTags(i,0), allTags(i,1), allTags(i,2));
const auto myTag = wedgeBasis.getDofTag(bfOrd);
if( !( (myTag(0) == allTags(i,0)) &&
(myTag(1) == allTags(i,1)) &&
(myTag(2) == allTags(i,2)) &&
(myTag(3) == allTags(i,3)) ) ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofOrdinal( {"
<< allTags(i,0) << ", "
<< allTags(i,1) << ", "
<< allTags(i,2) << ", "
<< allTags(i,3) << "}) = " << bfOrd <<" but \n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "}\n";
}
}
// Now do the same but loop over basis functions
for (ordinal_type bfOrd=0;bfOrd<numFields;++bfOrd) {
const auto myTag = wedgeBasis.getDofTag(bfOrd);
const auto myBfOrd = wedgeBasis.getDofOrdinal(myTag(0), myTag(1), myTag(2));
if( bfOrd != myBfOrd) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " getDofTag(" << bfOrd << ") = { "
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} but getDofOrdinal({"
<< myTag(0) << ", "
<< myTag(1) << ", "
<< myTag(2) << ", "
<< myTag(3) << "} ) = " << myBfOrd << "\n";
}
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
}
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 3: correctness of basis function values |\n"
<< "===============================================================================\n";
outStream -> precision(20);
// VALUE: correct basis function values in (F,P) format
const ValueType basisValues[] = {
1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1.00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.00 };
// GRAD and D1 values are stored in (F,P,D) format in a data file. Read file and do the test
std::vector<ValueType> basisGrads; // Flat array for the gradient values.
{
std::ifstream dataFile("../testdata/WEDGE_C2_GradVals.dat");
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_WEDGE_C2/test01): could not open GRAD values data file, test aborted.");
while (!dataFile.eof() ){
ValueType temp;
std::string line; // string for one line of input file
std::getline(dataFile, line); // get next line from file
std::stringstream data_line(line); // convert to stringstream
while (data_line >> temp) // extract value from line
basisGrads.push_back(temp); // push into vector
}
}
//D2: flat array with the values of D2 applied to basis functions. Multi-index is (F,P,D2cardinality)
std::vector<ValueType> basisD2;
{
std::ifstream dataFile("../testdata/WEDGE_C2_D2Vals.dat");
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_WEDGE_C2/test01): could not open D2 values data file, test aborted.");
while (!dataFile.eof() ){
ValueType temp;
std::string line; // string for one line of input file
std::getline(dataFile, line); // get next line from file
std::stringstream data_line(line); // convert to stringstream
while (data_line >> temp) // extract value from line
basisD2.push_back(temp); // push into vector
}
}
//D3: flat array with the values of D3 applied to basis functions. Multi-index is (F,P,D3cardinality)
std::vector<ValueType> basisD3;
{
std::ifstream dataFile("../testdata/WEDGE_C2_D3Vals.dat");
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_WEDGE_C2/test01): could not open D3 values data file, test aborted.");
while (!dataFile.eof() ){
ValueType temp;
std::string line; // string for one line of input file
std::getline(dataFile, line); // get next line from file
std::stringstream data_line(line); // convert to stringstream
while (data_line >> temp) // extract value from line
basisD3.push_back(temp); // push into vector
}
}
//D4: flat array with the values of D3 applied to basis functions. Multi-index is (F,P,D4cardinality)
std::vector<ValueType> basisD4;
{
std::ifstream dataFile("../testdata/WEDGE_C2_D4Vals.dat");
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_WEDGE_C2/test01): could not open D4 values data file, test aborted.");
while (!dataFile.eof() ){
ValueType temp;
std::string line; // string for one line of input file
std::getline(dataFile, line); // get next line from file
std::stringstream data_line(line); // convert to stringstream
while (data_line >> temp) // extract value from line
basisD4.push_back(temp); // push into vector
}
}
try {
DynRankViewHost ConstructWithLabel(wedgeNodesHost, 18, 3);
wedgeNodesHost(0,0) = 0.0; wedgeNodesHost(0,1) = 0.0; wedgeNodesHost(0,2) = -1.0;
wedgeNodesHost(1,0) = 1.0; wedgeNodesHost(1,1) = 0.0; wedgeNodesHost(1,2) = -1.0;
wedgeNodesHost(2,0) = 0.0; wedgeNodesHost(2,1) = 1.0; wedgeNodesHost(2,2) = -1.0;
wedgeNodesHost(3,0) = 0.0; wedgeNodesHost(3,1) = 0.0; wedgeNodesHost(3,2) = 1.0;
wedgeNodesHost(4,0) = 1.0; wedgeNodesHost(4,1) = 0.0; wedgeNodesHost(4,2) = 1.0;
wedgeNodesHost(5,0) = 0.0; wedgeNodesHost(5,1) = 1.0; wedgeNodesHost(5,2) = 1.0;
wedgeNodesHost(6,0) = 0.5; wedgeNodesHost(6,1) = 0.0; wedgeNodesHost(6,2) = -1.0;
wedgeNodesHost(7,0) = 0.5; wedgeNodesHost(7,1) = 0.5; wedgeNodesHost(7,2) = -1.0;
wedgeNodesHost(8,0) = 0.0; wedgeNodesHost(8,1) = 0.5; wedgeNodesHost(8,2) = -1.0;
wedgeNodesHost(9,0) = 0.0; wedgeNodesHost(9,1) = 0.0; wedgeNodesHost(9,2) = 0.0;
wedgeNodesHost(10,0)= 1.0; wedgeNodesHost(10,1)= 0.0; wedgeNodesHost(10,2)= 0.0;
wedgeNodesHost(11,0)= 0.0; wedgeNodesHost(11,1)= 1.0; wedgeNodesHost(11,2)= 0.0;
wedgeNodesHost(12,0)= 0.5; wedgeNodesHost(12,1)= 0.0; wedgeNodesHost(12,2)= 1.0;
wedgeNodesHost(13,0)= 0.5; wedgeNodesHost(13,1)= 0.5; wedgeNodesHost(13,2)= 1.0;
wedgeNodesHost(14,0)= 0.0; wedgeNodesHost(14,1)= 0.5; wedgeNodesHost(14,2)= 1.0;
wedgeNodesHost(15,0)= 0.5; wedgeNodesHost(15,1)= 0.0; wedgeNodesHost(15,2)= 0.0;
wedgeNodesHost(16,0)= 0.5; wedgeNodesHost(16,1)= 0.5; wedgeNodesHost(16,2)= 0.0;
wedgeNodesHost(17,0)= 0.0; wedgeNodesHost(17,1)= 0.5; wedgeNodesHost(17,2)= 0.0;
auto wedgeNodes = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), wedgeNodesHost);
Kokkos::deep_copy(wedgeNodes, wedgeNodesHost);
// Dimensions for the output arrays:
const ordinal_type numFields = wedgeBasis.getCardinality();
const ordinal_type numPoints = wedgeNodes.extent(0);
const ordinal_type spaceDim = wedgeBasis.getBaseCellTopology().getDimension();
const ordinal_type D2Cardin = getDkCardinality(OPERATOR_D2, spaceDim);
const ordinal_type D3Cardin = getDkCardinality(OPERATOR_D3, spaceDim);
const ordinal_type D4Cardin = getDkCardinality(OPERATOR_D4, spaceDim);
// Check VALUE of basis functions: resize vals to rank-2 container:
{
DynRankView vals = DynRankView("vals", numFields, numPoints);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_VALUE);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
const ordinal_type l = i + j * numFields;
if (std::abs(vals_host(i,j) - basisValues[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";
*outStream << "} computed value: " << vals_host(i,j)
<< " but reference value: " << basisValues[l] << "\n";
}
}
}
}
// Check GRAD of basis function: resize vals to rank-3 container
{
DynRankView vals = DynRankView("vals", numFields, numPoints, spaceDim);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_GRAD);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < spaceDim; ++k) {
// basisGrads is (F,P,D), compute offset:
const ordinal_type l = k + j * spaceDim + i * spaceDim * numPoints;
if (std::abs(vals_host(i,j,k) - basisGrads[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed grad component: " << vals_host(i,j,k)
<< " but reference grad component: " << basisGrads[l] << "\n";
}
}
}
}
}
// Check D1 of basis function (do not resize vals because it has the correct size: D1 = GRAD)
{
DynRankView vals = DynRankView("vals", numFields, numPoints, spaceDim);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_D1);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < spaceDim; ++k) {
// basisGrads is (F,P,D), compute offset:
const ordinal_type l = k + j * spaceDim + i * spaceDim * numPoints;
if (std::abs(vals_host(i,j,k) - basisGrads[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D1 component: " << vals_host(i,j,k)
<< " but reference D1 component: " << basisGrads[l] << "\n";
}
}
}
}
}
// Check D2 of basis function
{
DynRankView vals = DynRankView("vals", numFields, numPoints, D2Cardin);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_D2);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < D2Cardin; ++k) {
// basisGrads is (F,P,D), compute offset:
const ordinal_type l = k + j * D2Cardin + i * D2Cardin * numPoints;
if (std::abs(vals_host(i,j,k) - basisD2[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D2 component: " << vals_host(i,j,k)
<< " but reference D2 component: " << basisGrads[l] << "\n";
}
}
}
}
}
// Check D3 of basis function
{
DynRankView vals = DynRankView("vals", numFields, numPoints, D3Cardin);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_D3);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < D3Cardin; ++k) {
// basisGrads is (F,P,D), compute offset:
const ordinal_type l = k + j * D3Cardin + i * D3Cardin * numPoints;
if (std::abs(vals_host(i,j,k) - basisD3[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D3 component: " << vals_host(i,j,k)
<< " but reference D3 component: " << basisD3[l] << "\n";
}
}
}
}
}
// Check D4 of basis function
{
DynRankView vals = DynRankView("vals", numFields, numPoints, D4Cardin);
wedgeBasis.getValues(vals, wedgeNodes, OPERATOR_D4);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < D4Cardin; ++k) {
// basisGrads is (F,P,D), compute offset:
const ordinal_type l = k + j * D4Cardin + i * D4Cardin * numPoints;
if (std::abs(vals_host(i,j,k) - basisD4[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed D4 component: " << vals_host(i,j,k)
<< " but reference D4 component: " << basisD4[l] << "\n";
}
}
}
}
}
// Check all higher derivatives - must be zero.
{
const EOperator ops[] = { OPERATOR_D5,
OPERATOR_D6,
OPERATOR_D7,
OPERATOR_D8,
OPERATOR_D9,
OPERATOR_D10,
OPERATOR_MAX };
for (auto h=0;ops[h]!=OPERATOR_MAX;++h) {
const auto op = ops[h];
const ordinal_type DkCardin = getDkCardinality(op, spaceDim);
DynRankView vals("vals", numFields, numPoints, DkCardin);
wedgeBasis.getValues(vals, wedgeNodes, op);
auto vals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i1=0;i1<numFields; i1++)
for (ordinal_type i2=0;i2<numPoints; i2++)
for (ordinal_type i3=0;i3<DkCardin; i3++) {
if (std::abs(vals_host(i1,i2,i3)) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Get the multi-index of the value where the error is and the operator order
const auto ord = Intrepid2::getOperatorOrder(op);
*outStream << " At multi-index { "<<i1<<" "<<i2 <<" "<<i3;
*outStream << "} computed D"<< ord <<" component: " << vals_host(i1,i2,i3)
<< " but reference D" << ord << " component: 0 \n";
}
}
}
}
} catch (std::exception err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
}
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
// reset format state of std::cout
std::cout.copyfmt(oldFormatState);
return errorFlag;
}