int HGRAD_HEX_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"
<< "| |\n"
<< "| Unit Test (Basis_HGRAD_HEX_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"
<< "| |\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_HEX_C2_FEM<DeviceSpaceType,outputValueType,pointValueType> hexBasis;
//typedef typename decltype(hexBasis)::outputViewType outputViewType;
//typedef typename decltype(hexBasis)::pointViewType pointViewType;
*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 8 vertices of the reference HEX, its center, 12 edge nodes and 6 face centers
DynRankView ConstructWithLabel( hexNodes, 27, 3);
// Generic array for the output values; needs to be properly resized depending on the operator type
const auto numFields = hexBasis.getCardinality();
const auto numPoints = hexNodes.dimension(0);
const auto spaceDim = hexBasis.getBaseCellTopology().getDimension();
const auto D2Cardin = getDkCardinality(OPERATOR_D2, spaceDim);
const auto workSize = numFields*numPoints*D2Cardin;
DynRankView ConstructWithLabel(work, workSize);
DynRankView vals(work.data(), numFields, numPoints);
{
// exception #1: CURL cannot be applied to scalar functions in 3D
// resize vals to rank-3 container with dimensions (num. basis functions, num. points, arbitrary)
DynRankView tmpvals = DynRankView(work.data(), numFields, numPoints, 4);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(tmpvals, hexNodes, OPERATOR_CURL) );
}
{
// exception #2: DIV cannot be applied to scalar functions in 3D
// resize vals to rank-2 container with dimensions (num. basis functions, num. points)
DynRankView tmpvals = DynRankView(work.data(), numFields, numPoints);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(tmpvals, hexNodes, 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( hexBasis.getDofOrdinal(3,10,0) );
// exception #4
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(1,2,1) );
// exception #5
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(0,4,1) );
// exception #6
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofTag(28) );
// exception #7
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.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( hexBasis.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( hexBasis.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( hexBasis.getValues(badVals1, hexNodes, OPERATOR_VALUE) );
}
{
// exception #11 output values must be of rank-3 for OPERATOR_GRAD
DynRankView ConstructWithLabel(badVals2, 4, 3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals2, hexNodes, OPERATOR_GRAD) );
// exception #12 output values must be of rank-3 for OPERATOR_D1
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals2, hexNodes, OPERATOR_D1) );
// exception #13 output values must be of rank-3 for OPERATOR_D2
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals2, hexNodes, 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( hexBasis.getValues(badVals3, hexNodes, 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( hexBasis.getValues(badVals4, hexNodes, 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( hexBasis.getValues(badVals5, hexNodes, 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( hexBasis.getValues(badVals6, hexNodes, OPERATOR_D2) );
}
{
// exception #18: incorrect 2nd dimension of output array (must equal D3 cardinality in 3D)
DynRankView ConstructWithLabel(badVals7, numFields, numPoints, 50);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals7, hexNodes, OPERATOR_D3) );
}
#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 auto numFields = hexBasis.getCardinality();
const auto allTags = hexBasis.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 = hexBasis.getDofOrdinal(allTags(i,0), allTags(i,1), allTags(i,2));
const auto myTag = hexBasis.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 = hexBasis.getDofTag(bfOrd);
const auto myBfOrd = hexBasis.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);
try{
// VALUE: Each row gives the 8 correct basis set values at an evaluation point
const ValueType basisValues[] = {
1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000 };
// GRAD, D1, D2, D3 and D4 test values are stored in files due to their large size
std::string fileName;
std::ifstream dataFile;
// GRAD and D1 values are stored in (F,P,D) format in a data file. Read file and do the test
std::vector<double> basisGrads; // Flat array for the gradient values.
fileName = "../testdata/HEX_C2_GradVals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open GRAD values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
// It turns out that just closing and then opening the ifstream variable does not reset it
// and subsequent open() command fails. One fix is to explicitely clear the ifstream, or
// scope the variables.
dataFile.close();
dataFile.clear();
//D2: flat array with the values of D2 applied to basis functions. Multi-index is (F,P,D2cardinality)
std::vector<double> basisD2;
fileName = "../testdata/HEX_C2_D2Vals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D2 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
//D3: flat array with the values of D3 applied to basis functions. Multi-index is (F,P,D3cardinality)
std::vector<double> basisD3;
fileName = "../testdata/HEX_C2_D3Vals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D3 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
//D4: flat array with the values of D3 applied to basis functions. Multi-index is (F,P,D4cardinality)
std::vector<double> basisD4;
fileName = "../testdata/HEX_C2_D4Vals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D4 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
DynRankViewHost ConstructWithLabel(hexNodesHost, 27, 3);
// vertices
hexNodesHost(0, 0) = -1.0; hexNodesHost(0, 1) = -1.0; hexNodesHost(0, 2) = -1.0;
hexNodesHost(1, 0) = 1.0; hexNodesHost(1, 1) = -1.0; hexNodesHost(1, 2) = -1.0;
hexNodesHost(2, 0) = 1.0; hexNodesHost(2, 1) = 1.0; hexNodesHost(2, 2) = -1.0;
hexNodesHost(3, 0) = -1.0; hexNodesHost(3, 1) = 1.0; hexNodesHost(3, 2) = -1.0;
hexNodesHost(4, 0) = -1.0; hexNodesHost(4, 1) = -1.0; hexNodesHost(4, 2) = 1.0;
hexNodesHost(5, 0) = 1.0; hexNodesHost(5, 1) = -1.0; hexNodesHost(5, 2) = 1.0;
hexNodesHost(6, 0) = 1.0; hexNodesHost(6, 1) = 1.0; hexNodesHost(6, 2) = 1.0;
hexNodesHost(7, 0) = -1.0; hexNodesHost(7, 1) = 1.0; hexNodesHost(7, 2) = 1.0;
// nodes on edges
hexNodesHost(8, 0) = 0.0; hexNodesHost(8, 1) = -1.0; hexNodesHost(8, 2) = -1.0;
hexNodesHost(9, 0) = 1.0; hexNodesHost(9, 1) = 0.0; hexNodesHost(9, 2) = -1.0;
hexNodesHost(10,0) = 0.0; hexNodesHost(10,1) = 1.0; hexNodesHost(10,2) = -1.0;
hexNodesHost(11,0) = -1.0; hexNodesHost(11,1) = 0.0; hexNodesHost(11,2) = -1.0;
hexNodesHost(12,0) = -1.0; hexNodesHost(12,1) = -1.0; hexNodesHost(12,2) = 0.0;
hexNodesHost(13,0) = 1.0; hexNodesHost(13,1) = -1.0; hexNodesHost(13,2) = 0.0;
hexNodesHost(14,0) = 1.0; hexNodesHost(14,1) = 1.0; hexNodesHost(14,2) = 0.0;
hexNodesHost(15,0) = -1.0; hexNodesHost(15,1) = 1.0; hexNodesHost(15,2) = 0.0;
hexNodesHost(16,0) = 0.0; hexNodesHost(16,1) = -1.0; hexNodesHost(16,2) = 1.0;
hexNodesHost(17,0) = 1.0; hexNodesHost(17,1) = 0.0; hexNodesHost(17,2) = 1.0;
hexNodesHost(18,0) = 0.0; hexNodesHost(18,1) = 1.0; hexNodesHost(18,2) = 1.0;
hexNodesHost(19,0) = -1.0; hexNodesHost(19,1) = 0.0; hexNodesHost(19,2) = 1.0;
// center
hexNodesHost(20,0) = 0.0; hexNodesHost(20,1) = 0.0; hexNodesHost(20,2) = 0.0;
// Face nodes
hexNodesHost(21,0) = 0.0; hexNodesHost(21,1) = 0.0; hexNodesHost(21,2) = -1.0;
hexNodesHost(22,0) = 0.0; hexNodesHost(22,1) = 0.0; hexNodesHost(22,2) = 1.0;
hexNodesHost(23,0) = -1.0; hexNodesHost(23,1) = 0.0; hexNodesHost(23,2) = 0.0;
hexNodesHost(24,0) = 1.0; hexNodesHost(24,1) = 0.0; hexNodesHost(24,2) = 0.0;
hexNodesHost(25,0) = 0.0; hexNodesHost(25,1) = -1.0; hexNodesHost(25,2) = 0.0;
hexNodesHost(26,0) = 0.0; hexNodesHost(26,1) = 1.0; hexNodesHost(26,2) = 0.0;
auto hexNodes = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), hexNodesHost);
Kokkos::deep_copy(hexNodes, hexNodesHost);
// Dimensions for the output arrays:
const auto numFields = hexBasis.getCardinality();
const auto numPoints = hexNodes.dimension(0);
const auto spaceDim = hexBasis.getBaseCellTopology().getDimension();
const auto D2Cardin = getDkCardinality(OPERATOR_D2, spaceDim);
const auto D3Cardin = getDkCardinality(OPERATOR_D3, spaceDim);
const auto D4Cardin = getDkCardinality(OPERATOR_D4, spaceDim);
{
// Generic array for values, grads, curls, etc. that will be properly sized before each call
DynRankView ConstructWithLabel(vals, numFields, numPoints);
// Check VALUE of basis functions: resize vals to rank-2 container:
hexBasis.getValues(vals, hexNodes, 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";
}
}
}
}
{
DynRankView ConstructWithLabel(vals, numFields, numPoints, spaceDim);
// Check GRAD of basis function: resize vals to rank-3 container
hexBasis.getValues(vals, hexNodes, 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) {
// basisGrads is (F,P,D), compute offset:
const auto 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)
hexBasis.getValues(vals, hexNodes, OPERATOR_D1);
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) {
// basisGrads is (F,P,D), compute offset:
const auto 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 ConstructWithLabel(vals, numFields, numPoints, D2Cardin);
hexBasis.getValues(vals, hexNodes, 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) {
for (auto k = 0; k < D2Cardin; ++k) {
// basisD2 is (F,P,Dk), compute offset:
const auto 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: " << basisD2[l] << "\n";
}
}
}
}
}
{
// Check D3 of basis function
DynRankView ConstructWithLabel(vals, numFields, numPoints, D3Cardin);
hexBasis.getValues(vals, hexNodes, OPERATOR_D3);
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 < D3Cardin; ++k) {
// basisD3 is (F,P,Dk), compute offset:
const auto 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 ConstructWithLabel(vals, numFields, numPoints, D4Cardin);
hexBasis.getValues(vals, hexNodes, OPERATOR_D4);
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 < D4Cardin; k++) {
// basisD4 is (F,P,Dk), compute offset:
int 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: " << basisD2[l] << "\n"; //D2 same as D4?
}
}
}
}
}
{
// Check D7 to D10 - must be zero. This basis does not support D5 and D6
const EOperator ops[] = { OPERATOR_D7,
OPERATOR_D8,
OPERATOR_D9,
OPERATOR_D10,
OPERATOR_MAX };
for (auto h=0;ops[h]!=OPERATOR_MAX;++h) {
const auto op = ops[h];
// The last dimension is the number of kth derivatives and needs to be resized for every Dk
const auto DkCardin = getDkCardinality(op, spaceDim);
DynRankView ConstructWithLabel(vals, numFields, numPoints, DkCardin);
hexBasis.getValues(vals, hexNodes, 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_host(i1,i2,i3)
<< " but reference D" << ord << " component: 0 \n";
}
}
}
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 4: correctness of DoF locations |\n"
<< "===============================================================================\n";
try{
const auto numFields = hexBasis.getCardinality();
const auto spaceDim = hexBasis.getBaseCellTopology().getDimension();
// Check exceptions.
ordinal_type nthrow = 0, ncatch = 0;
#ifdef HAVE_INTREPID2_DEBUG
{
DynRankView ConstructWithLabel(badVals, 1, 2, 3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofCoords(badVals) );
}
{
DynRankView ConstructWithLabel(badVals, 3, 2);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofCoords(badVals) );
}
{
DynRankView ConstructWithLabel(badVals, 27, 2);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofCoords(badVals) );
}
#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 (" << ncatch << ")\n";
}
DynRankView ConstructWithLabel(bvals, numFields, numFields);
DynRankView ConstructWithLabel(cvals, numFields, spaceDim);
// Check mathematical correctness.
hexBasis.getDofCoords(cvals);
hexBasis.getValues(bvals, cvals, OPERATOR_VALUE);
auto cvals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), cvals);
Kokkos::deep_copy(cvals_host, cvals);
auto bvals_host = Kokkos::create_mirror_view(typename HostSpaceType::memory_space(), bvals);
Kokkos::deep_copy(bvals_host, bvals);
char buffer[120];
for (auto i=0; i<bvals.dimension(0); ++i) {
for (auto j=0; j<bvals.dimension(1); ++j) {
if ((i != j) && (std::abs(bvals_host(i,j) - 0.0) > tol)) {
errorFlag++;
sprintf(buffer, "\nValue of basis function %d at (%6.4e, %6.4e, %6.4e) is %6.4e but should be %6.4e!\n", i, cvals_host(i,0), cvals_host(i,1), cvals_host(i,2), bvals_host(i,j), 0.0);
*outStream << buffer;
}
else if ((i == j) && (std::abs(bvals_host(i,j) - 1.0) > tol)) {
errorFlag++;
sprintf(buffer, "\nValue of basis function %d at (%6.4e, %6.4e, %6.4e) is %6.4e but should be %6.4e!\n", i, cvals_host(i,0), cvals_host(i,1), cvals_host(i,2), bvals_host(i,j), 1.0);
*outStream << buffer;
}
}
}
} 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_HEX_Cn_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_HEX_Cn_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"
<< "| Robert Kirby ([email protected]), |\n"
<< "| Denis Ridzal ([email protected]), |\n"
<< "| Kara Peterson ([email protected]), |\n"
<< "| Kyungjoo Kim ([email protected]), |\n"
<< "| Mauro Perego ([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<PointValueType,DeviceSpaceType> DynRankViewPointValueType;
typedef Kokkos::DynRankView<OutValueType,DeviceSpaceType> DynRankViewOutValueType;
typedef typename ScalarTraits<OutValueType>::scalar_type scalar_type;
typedef Kokkos::DynRankView<scalar_type, DeviceSpaceType> DynRankViewScalarValueType;
typedef Kokkos::DynRankView<scalar_type, HostSpaceType> DynRankViewHostScalarValueType;
#define ConstructWithLabelScalar(obj, ...) obj(#obj, __VA_ARGS__)
const scalar_type tol = tolerence();
int errorFlag = 0;
typedef Basis_HGRAD_HEX_Cn_FEM<DeviceSpaceType,OutValueType,PointValueType> HexBasisType;
constexpr ordinal_type maxOrder = Parameters::MaxOrder;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: Basis creation, exceptions tests |\n"
<< "===============================================================================\n";
try {
#ifdef HAVE_INTREPID2_DEBUG
ordinal_type nthrow = 0, ncatch = 0;
constexpr ordinal_type order = 3;
if(order < maxOrder) {
HexBasisType hexBasis(order);
// Define array containing array of nodes to evaluate
DynRankViewPointValueType ConstructWithLabelPointView(hexNodes, 27, 3);
// Generic array for the output values; needs to be properly resized depending on the operator type
const ordinal_type numFields = hexBasis.getCardinality();
const ordinal_type numPoints = hexNodes.extent(0);
//const ordinal_type spaceDim = hexBasis.getBaseCellTopology().getDimension();
// exception 1 - 2: CURL and DIV is not supported.
{
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, 3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, hexNodes, OPERATOR_CURL) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, hexNodes, 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
{
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(3,10,0) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(1,2,3) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(0,4,1) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofTag(numFields) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofTag(-1) );
}
// Exceptions 8-18 test exception handling with incorrectly dimensioned input/output arrays
// exception #8: input points array must be of rank-2
{
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints);
{
// exception #8: input points array must be of rank-2
DynRankViewPointValueType ConstructWithLabelPointView(badPoints, 4, 5, 3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, badPoints, OPERATOR_VALUE) );
}
{
// exception #9: dimension 1 in the input point array must equal space dimension of the cell
DynRankViewPointValueType ConstructWithLabelPointView(badPoints, 4, 4);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, badPoints, OPERATOR_VALUE) );
}
{
// exception #10: output values must be of rank-2 for OPERATOR_VALUE
DynRankViewOutValueType ConstructWithLabelOutView(badVals, 4, 3, 1);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE) );
}
{
DynRankViewOutValueType ConstructWithLabelOutView(badVals, 4, 3);
// exception #11: output values must be of rank-3 for OPERATOR_GRAD
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_GRAD) );
// exception #12: output values must be of rank-3 for OPERATOR_CURL
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_D1) );
// exception #13: output values must be of rank-3 for OPERATOR_D2
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_D2) );
}
}
{
// exception #14: incorrect 0th dimension of output array (must equal number of basis functions)
DynRankViewOutValueType ConstructWithLabelOutView(badVals, hexBasis.getCardinality() + 1, hexNodes.extent(0));
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE) );
}
{
// exception #15: incorrect 1st dimension of output array (must equal number of points)
DynRankViewOutValueType ConstructWithLabelOutView(badVals, hexBasis.getCardinality(), hexNodes.extent(0) + 1);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE) );
}
{
// exception #16: incorrect 2nd dimension of output array (must equal spatial dimension)
DynRankViewOutValueType ConstructWithLabelOutView(badVals, hexBasis.getCardinality(), hexNodes.extent(0), 2);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_GRAD) );
}
{
DynRankViewOutValueType ConstructWithLabelOutView(badVals, hexBasis.getCardinality(), hexNodes.extent(0), 40);
// exception #17: incorrect 2nd dimension of output array (must equal spatial dimension)
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_D2) );
// exception #18: incorrect 2nd dimension of output array (must equal spatial dimension)
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_D3) );
}
}
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << nthrow << ")\n";
}
#endif
} 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 order = std::min(5, maxOrder);
HexBasisType hexBasis(order);
const ordinal_type numFields = hexBasis.getCardinality();
const auto allTags = hexBasis.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 = hexBasis.getDofOrdinal(allTags(i,0), allTags(i,1), allTags(i,2));
const auto myTag = hexBasis.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 = hexBasis.getDofTag(bfOrd);
const auto myBfOrd = hexBasis.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::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
try {
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 3: Testing Kronecker property of basis functions |\n"
<< "===============================================================================\n";
const ordinal_type order = std::min(3,maxOrder);
HexBasisType hexBasis(order, POINTTYPE_WARPBLEND);
constexpr ordinal_type dim=3;
const ordinal_type basisCardinality = hexBasis.getCardinality();
DynRankViewScalarValueType ConstructWithLabelScalar(lattice_scalar, basisCardinality , dim);
DynRankViewPointValueType ConstructWithLabelPointView(lattice, basisCardinality , dim);
hexBasis.getDofCoords(lattice_scalar);
RealSpaceTools<DeviceSpaceType>::clone(lattice,lattice_scalar);
auto lattice_host = Kokkos::create_mirror_view(lattice);
DynRankViewOutValueType ConstructWithLabelOutView(basisAtLattice, basisCardinality, basisCardinality);
hexBasis.getValues(basisAtLattice, lattice, OPERATOR_VALUE);
auto h_basisAtLattice = Kokkos::create_mirror_view(basisAtLattice);
Kokkos::deep_copy(h_basisAtLattice, basisAtLattice);
for(ordinal_type iface =0; iface<6; iface++) {
auto numFaceDofs = hexBasis.getDofCount(2,iface);
for(ordinal_type i=0; i<numFaceDofs; i++) {
auto idof = hexBasis.getDofOrdinal(2,iface,i);
for(ordinal_type j=0; j<numFaceDofs; j++) {
auto jdof = hexBasis.getDofOrdinal(2,iface,j);
if ( idof==jdof && std::abs( h_basisAtLattice(idof,jdof) - 1.0 ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << idof << " does not have unit value at its node (" << h_basisAtLattice(idof,jdof) <<")\n";
}
if ( i!=j && std::abs( h_basisAtLattice(idof,jdof) ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << idof << " does not vanish at node " << jdof << "\n";
*outStream << " Basis function value is " << h_basisAtLattice(idof,jdof) << "\n";
}
}
}
}
// test for Kronecker property
for (int i=0;i<basisCardinality;i++) {
for (int j=0;j<basisCardinality;j++) {
if ( i==j && std::abs( h_basisAtLattice(i,j) - 1.0 ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << i << " does not have unit value at its node (" << h_basisAtLattice(i,j) <<")\n";
}
if ( i!=j && std::abs( h_basisAtLattice(i,j) ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << i << " does not vanish at node " << j << "\n";
*outStream << " Basis function value is " << h_basisAtLattice(i,j) << "\n";
}
}
}
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 4: correctness of basis function values |\n"
<< "===============================================================================\n";
outStream -> precision(20);
// VALUE: Each row gives the 27 correct basis set values at an evaluation point
const scalar_type basisValues[] = {
1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.000 };
// GRAD, D1, D2, D3 and D4 test values are stored in files due to their large size
std::string fileName;
std::ifstream dataFile;
// GRAD and D1 values are stored in (F,P,D) format in a data file. Read file and do the test
std::vector<scalar_type> basisGrads; // Flat array for the gradient values.
{
fileName = "../testdata/HEX_C2_GradVals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open GRAD values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
}
//D2: flat array with the values of D2 applied to basis functions. Multi-index is (F,P,D2cardinality)
std::vector<scalar_type> basisD2;
{
fileName = "../testdata/HEX_C2_D2Vals.dat";
dataFile.open(fileName.c_str());
INTREPID2_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D2 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
}
//D3: flat array with the values of D3 applied to basis functions. Multi-index is (F,P,D3cardinality)
std::vector<scalar_type> basisD3;
{
fileName = "../testdata/HEX_C2_D3Vals.dat";
dataFile.open(fileName.c_str());
TEUCHOS_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D3 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
}
//D4: flat array with the values of D applied to basis functions. Multi-index is (F,P,D4cardinality)
std::vector<scalar_type> basisD4;
{
fileName = "../testdata/HEX_C2_D4Vals.dat";
dataFile.open(fileName.c_str());
TEUCHOS_TEST_FOR_EXCEPTION( !dataFile.good(), std::logic_error,
">>> ERROR (HGRAD_HEX_C2/test01): could not open D4 values data file, test aborted.");
while (!dataFile.eof() ){
double 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
}
}
dataFile.close();
dataFile.clear();
}
try{
constexpr ordinal_type order = 2;
if(order < maxOrder) {
HexBasisType hexBasis(order);
DynRankViewHostScalarValueType ConstructWithLabelScalar(hexNodesHost, 27, 3);
DynRankViewPointValueType ConstructWithLabelPointView(hexNodes, 27, 3);
// do it lexicographically as a lattice
hexNodesHost(0, 0) = -1.0; hexNodesHost(0, 1) = -1.0; hexNodesHost(0, 2) = -1.0;
hexNodesHost(1, 0) = 0.0; hexNodesHost(1, 1) = -1.0; hexNodesHost(1, 2) = -1.0;
hexNodesHost(2, 0) = 1.0; hexNodesHost(2, 1) = -1.0; hexNodesHost(2, 2) = -1.0;
hexNodesHost(3, 0) = -1.0; hexNodesHost(3, 1) = 0.0; hexNodesHost(3, 2) = -1.0;
hexNodesHost(4, 0) = 0.0; hexNodesHost(4, 1) = 0.0; hexNodesHost(4, 2) = -1.0;
hexNodesHost(5, 0) = 1.0; hexNodesHost(5, 1) = 0.0; hexNodesHost(5, 2) = -1.0;
hexNodesHost(6, 0) = -1.0; hexNodesHost(6, 1) = 1.0; hexNodesHost(6, 2) = -1.0;
hexNodesHost(7, 0) = 0.0; hexNodesHost(7, 1) = 1.0; hexNodesHost(7, 2) = -1.0;
hexNodesHost(8, 0) = 1.0; hexNodesHost(8, 1) = 1.0; hexNodesHost(8, 2) = -1.0;
hexNodesHost(9, 0) = -1.0; hexNodesHost(9, 1) = -1.0; hexNodesHost(9, 2) = 0.0;
hexNodesHost(10, 0) = 0.0; hexNodesHost(10, 1) = -1.0; hexNodesHost(10, 2) = 0.0;
hexNodesHost(11, 0) = 1.0; hexNodesHost(11, 1) = -1.0; hexNodesHost(11, 2) = 0.0;
hexNodesHost(12, 0) = -1.0; hexNodesHost(12, 1) = 0.0; hexNodesHost(12, 2) = 0.0;
hexNodesHost(13, 0) = 0.0; hexNodesHost(13, 1) = 0.0; hexNodesHost(13, 2) = 0.0;
hexNodesHost(14, 0) = 1.0; hexNodesHost(14, 1) = 0.0; hexNodesHost(14, 2) = 0.0;
hexNodesHost(15, 0) = -1.0; hexNodesHost(15, 1) = 1.0; hexNodesHost(15, 2) = 0.0;
hexNodesHost(16, 0) = 0.0; hexNodesHost(16, 1) = 1.0; hexNodesHost(16, 2) = 0.0;
hexNodesHost(17, 0) = 1.0; hexNodesHost(17, 1) = 1.0; hexNodesHost(17, 2) = 0.0;
hexNodesHost(18, 0) = -1.0; hexNodesHost(18, 1) = -1.0; hexNodesHost(18, 2) = 1.0;
hexNodesHost(19, 0) = 0.0; hexNodesHost(19, 1) = -1.0; hexNodesHost(19, 2) = 1.0;
hexNodesHost(20, 0) = 1.0; hexNodesHost(20, 1) = -1.0; hexNodesHost(20, 2) = 1.0;
hexNodesHost(21, 0) = -1.0; hexNodesHost(21, 1) = 0.0; hexNodesHost(21, 2) = 1.0;
hexNodesHost(22, 0) = 0.0; hexNodesHost(22, 1) = 0.0; hexNodesHost(22, 2) = 1.0;
hexNodesHost(23, 0) = 1.0; hexNodesHost(23, 1) = 0.0; hexNodesHost(23, 2) = 1.0;
hexNodesHost(24, 0) = -1.0; hexNodesHost(24, 1) = 1.0; hexNodesHost(24, 2) = 1.0;
hexNodesHost(25, 0) = 0.0; hexNodesHost(25, 1) = 1.0; hexNodesHost(25, 2) = 1.0;
hexNodesHost(26, 0) = 1.0; hexNodesHost(26, 1) = 1.0; hexNodesHost(26, 2) = 1.0;
auto hexNodes_scalar = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), hexNodesHost);
Kokkos::deep_copy(hexNodes_scalar, hexNodesHost);
RealSpaceTools<DeviceSpaceType>::clone(hexNodes, hexNodes_scalar);
// Dimensions for the output arrays:
const ordinal_type numFields = hexBasis.getCardinality();
const ordinal_type numPoints = hexNodes.extent(0);
const ordinal_type spaceDim = hexBasis.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);
*outStream << " -- Testing OPERATOR_VALUE \n";
{
// Check VALUE of basis functions: resize vals to rank-2 container:
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints);
hexBasis.getValues(vals, hexNodes, OPERATOR_VALUE);
auto vals_host = Kokkos::create_mirror_view(vals);
Kokkos::deep_copy(vals_host, vals);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
// Compute offset for (F,P) container
const ordinal_type l = j + i * numPoints;
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";
}
}
}
}
*outStream << " -- Testing OPERATOR_GRAD \n";
{
// Check GRAD of basis function: resize vals to rank-3 container
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, spaceDim);
hexBasis.getValues(vals, hexNodes, OPERATOR_GRAD);
auto vals_host = Kokkos::create_mirror_view(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";
}
}
}
}
}
*outStream << " -- Testing OPERATOR_D1 \n";
{
// Check GRAD of basis function: resize vals to rank-3 container
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, spaceDim);
hexBasis.getValues(vals, hexNodes, OPERATOR_D1);
auto vals_host = Kokkos::create_mirror_view(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";
}
}
}
}
}
*outStream << " -- Testing OPERATOR_D2 \n";
{
// Check GRAD of basis function: resize vals to rank-3 container
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, D2Cardin);
hexBasis.getValues(vals, hexNodes, OPERATOR_D2);
auto vals_host = Kokkos::create_mirror_view(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 grad component: " << vals_host(i,j,k)
<< " but reference grad component: " << basisD2[l] << "\n";
}
}
}
}
}
*outStream << " -- Testing OPERATOR_D3 \n";
{
// Check GRAD of basis function: resize vals to rank-3 container
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, D3Cardin);
hexBasis.getValues(vals, hexNodes, OPERATOR_D3);
auto vals_host = Kokkos::create_mirror_view(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 grad component: " << vals_host(i,j,k)
<< " but reference grad component: " << basisD3[l] << "\n";
}
}
}
}
}
*outStream << " -- Testing OPERATOR_D4 \n";
{
// Check GRAD of basis function: resize vals to rank-3 container
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, D4Cardin);
hexBasis.getValues(vals, hexNodes, OPERATOR_D4);
auto vals_host = Kokkos::create_mirror_view(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 grad component: " << vals_host(i,j,k)
<< " but reference grad component: " << basisD4[l] << "\n";
}
}
}
}
}
// // Check D7 to D10 - must be zero. This basis does not cover D5 and D6
const EOperator ops[4] = { OPERATOR_D7,
OPERATOR_D8,
OPERATOR_D9,
OPERATOR_D10 };
for (ordinal_type oid=0;oid<4;++oid) {
*outStream << " -- Testing OPERATOR_D" << (oid+7) << "\n";
const auto op = ops[oid];
const ordinal_type DkCardin = Intrepid2::getDkCardinality(op, spaceDim);
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, DkCardin);
hexBasis.getValues(vals, hexNodes, op);
auto vals_host = Kokkos::create_mirror_view(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 < DkCardin; ++k) {
// basisGrads is (F,P,D), compute offset:
if (std::abs(vals_host(i,j,k)) > 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: 0.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;
}
int HCURL_HEX_In_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 HCURL_HEX_In_FEM |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]), |\n"
<< "| Robert Kirby ([email protected]), |\n"
<< "| Denis Ridzal ([email protected]), |\n"
<< "| Kara Peterson ([email protected]), |\n"
<< "| Kyungjoo Kim ([email protected]), |\n"
<< "| Mauro Perego ([email protected]). |\n"
<< "| |\n"
<< "===============================================================================\n";
typedef Kokkos::DynRankView<PointValueType,DeviceSpaceType> DynRankViewPointValueType;
typedef Kokkos::DynRankView<OutValueType,DeviceSpaceType> DynRankViewOutValueType;
typedef typename ScalarTraits<OutValueType>::scalar_type scalar_type;
typedef Kokkos::DynRankView<scalar_type, DeviceSpaceType> DynRankViewScalarValueType;
typedef Kokkos::DynRankView<scalar_type, HostSpaceType> DynRankViewHostScalarValueType;
#define ConstructWithLabelScalar(obj, ...) obj(#obj, __VA_ARGS__)
const scalar_type tol = tolerence();
int errorFlag = 0;
typedef Basis_HCURL_HEX_In_FEM<DeviceSpaceType,OutValueType,PointValueType> HexBasisType;
constexpr ordinal_type maxOrder = Parameters::MaxOrder ;
constexpr ordinal_type dim = 3;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: Exception testing |\n"
<< "===============================================================================\n";
try {
#ifdef HAVE_INTREPID2_DEBUG
ordinal_type nthrow = 0, ncatch = 0;
const ordinal_type order = 1;
HexBasisType hexBasis(order);
// Array of reference hex nodes - used for evaluation of basis
DynRankViewHostScalarValueType ConstructWithLabelScalar(hexNodesHost, 8, 3);
hexNodesHost(0,0) = -1.0; hexNodesHost(0,1) = -1.0; hexNodesHost(0,2) = -1.0;
hexNodesHost(1,0) = 1.0; hexNodesHost(1,1) = -1.0; hexNodesHost(1,2) = -1.0;
hexNodesHost(2,0) = -1.0; hexNodesHost(2,1) = 1.0; hexNodesHost(2,2) = -1.0;
hexNodesHost(3,0) = 1.0; hexNodesHost(3,1) = 1.0; hexNodesHost(3,2) = -1.0;
hexNodesHost(4,0) = -1.0; hexNodesHost(4,1) = -1.0; hexNodesHost(4,2) = 1.0;
hexNodesHost(5,0) = 1.0; hexNodesHost(5,1) = -1.0; hexNodesHost(5,2) = 1.0;
hexNodesHost(6,0) = -1.0; hexNodesHost(6,1) = 1.0; hexNodesHost(6,2) = 1.0;
hexNodesHost(7,0) = 1.0; hexNodesHost(7,1) = 1.0; hexNodesHost(7,2) = 1.0;
auto hexNodes_scalar = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), hexNodesHost);
Kokkos::deep_copy(hexNodes_scalar, hexNodesHost);
DynRankViewPointValueType ConstructWithLabelPointView(hexNodes, 8, 3);
RealSpaceTools<DeviceSpaceType>::clone(hexNodes, hexNodes_scalar);
// Array dimensions
const ordinal_type numFields = hexBasis.getCardinality();
const ordinal_type numPoints = hexNodes.extent(0);
const ordinal_type spaceDim = hexBasis.getBaseCellTopology().getDimension();
{
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, spaceDim);
// exception #1: GRAD cannot be applied to HCURL functions
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, hexNodes, OPERATOR_GRAD) );
// exception #2: DIV cannot be applied to HCURL functions
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, hexNodes, 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
//
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(3,0,0) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(1,1,1) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofOrdinal(0,4,1) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofTag(12) );
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getDofTag(-1) );
}
{
// Exceptions 8-15 test exception handling with incorrectly dimensioned input/output arrays
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, spaceDim);
{
// Exception #8: input points array must be of rank-2
DynRankViewPointValueType ConstructWithLabelPointView(badPoints,4,5,3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, badPoints, OPERATOR_VALUE));
}
{
// Exception #9: dimension 1 in the input point array must equal space dimension of the cell
DynRankViewPointValueType ConstructWithLabelPointView(badPoints,4,2);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(vals, badPoints, OPERATOR_VALUE));
}
{
// Exception #10: output values must be of rank-3 for OPERATOR_VALUE
DynRankViewOutValueType ConstructWithLabelOutView(badVals,4,3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE));
}
{
// Exception #11: output values must be of rank-3 for OPERATOR_CURL
DynRankViewOutValueType ConstructWithLabelOutView(badVals,4,3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_CURL));
}
{
// Exception #12: incorrect 0th dimension of output array (must equal number of basis functions)
DynRankViewOutValueType ConstructWithLabelOutView(badVals,numFields+1,numPoints,3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE));
}
{
// Exception #13: incorrect 1st dimension of output array (must equal number of points)
DynRankViewOutValueType ConstructWithLabelOutView(badVals,numFields,numPoints+1,3);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE));
}
{
// Exception #14: incorrect 2nd dimension of output array (must equal the space dimension)
DynRankViewOutValueType ConstructWithLabelOutView(badVals,numFields,numPoints,4);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_VALUE));
}
{
// Exception #15: incorrect 2nd dimension of output array (must equal the space dimension)
DynRankViewOutValueType ConstructWithLabelOutView(badVals,numFields,numPoints,4);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_CURL));
}
}
{
// Exception #16: D2 cannot be applied to HCURL functions
DynRankViewOutValueType ConstructWithLabelOutView(badVals,numFields,numPoints,4);
INTREPID2_TEST_ERROR_EXPECTED( hexBasis.getValues(badVals, hexNodes, OPERATOR_D2));
}
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << nthrow << ")\n";
}
#endif
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 2: Testing OPERATOR_VALUE (Kronecker property using dof coefficients) |\n"
<< "===============================================================================\n";
try {
const ordinal_type order = std::min(3, maxOrder);
HexBasisType hexBasis(order);
const ordinal_type numFields = hexBasis.getCardinality();
DynRankViewScalarValueType ConstructWithLabelScalar(dofCoords_scalar, numFields, dim);
hexBasis.getDofCoords(dofCoords_scalar);
DynRankViewScalarValueType ConstructWithLabelScalar(dofCoeffs, numFields, dim);
hexBasis.getDofCoeffs(dofCoeffs);
DynRankViewPointValueType ConstructWithLabelPointView(dofCoords, numFields , dim);
RealSpaceTools<DeviceSpaceType>::clone(dofCoords,dofCoords_scalar);
DynRankViewOutValueType ConstructWithLabelOutView(basisAtDofCoords, numFields, numFields, dim);
hexBasis.getValues(basisAtDofCoords, dofCoords, OPERATOR_VALUE);
auto h_dofCoords = Kokkos::create_mirror_view(dofCoords);
Kokkos::deep_copy(h_dofCoords, dofCoords);
auto h_dofCoeffs = Kokkos::create_mirror_view(dofCoeffs);
Kokkos::deep_copy(h_dofCoeffs, dofCoeffs);
auto h_basisAtDofCoords = Kokkos::create_mirror_view(basisAtDofCoords);
Kokkos::deep_copy(h_basisAtDofCoords, basisAtDofCoords);
for (int i=0;i<numFields;i++) {
for (int j=0;j<numFields;j++) {
OutValueType dofValue = 0.0;
for(ordinal_type d=0;d<dim;++d)
dofValue += h_basisAtDofCoords(i,j,d)*h_dofCoeffs(j,d);
// check values
const scalar_type expected_dofValue = (i == j);
if (std::abs(dofValue - expected_dofValue) > tol) {
errorFlag++;
std::stringstream ss;
ss << "\nValue of basis function " << i << " at (" << h_dofCoords(i,0) << ", " << h_dofCoords(i,1) << ", "<< h_dofCoords(i,2) << ") is " << dofValue << " but should be " << expected_dofValue << "\n";
*outStream << ss.str();
}
}
}
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 3: Testing OPERATOR_VALUE (Kronecker property) |\n"
<< "===============================================================================\n";
try {
const ordinal_type order = std::min(3, maxOrder);
HexBasisType hexBasis(order);
shards::CellTopology hex_8(shards::getCellTopologyData<shards::Hexahedron<8> >());
const ordinal_type numFields = hexBasis.getCardinality();
DynRankViewScalarValueType ConstructWithLabelScalar(dofCoords_scalar, numFields, dim);
hexBasis.getDofCoords(dofCoords_scalar);
DynRankViewPointValueType ConstructWithLabelPointView(dofCoords, numFields , dim);
RealSpaceTools<DeviceSpaceType>::clone(dofCoords,dofCoords_scalar);
DynRankViewOutValueType ConstructWithLabelOutView(basisAtDofCoords, numFields, numFields, dim);
hexBasis.getValues(basisAtDofCoords, dofCoords, OPERATOR_VALUE);
auto h_basisAtDofCoords = Kokkos::create_mirror_view(basisAtDofCoords);
Kokkos::deep_copy(h_basisAtDofCoords, basisAtDofCoords);
// These are tensor product basis functions where the local edge/basis orientation
// is assumed to be in the positive x, y, or z direction.
// For simplicity we do not need to compute tangents, but can just access values
// from the correct indices assuming that tangents are (1,0,0), (0,1,0), or (0,0,1)
// test for Kronecker property
for (int i=0;i<numFields;i++) {
for (int j=0;j<numFields;j++) {
// initialize
OutValueType dofValue = 0;
// get index given that dofs are arranged by dimension, all x dofs, all y dofs, all z dofs
auto dofsPerDim = numFields/dim;
auto k_ind = j/dofsPerDim;
dofValue = h_basisAtDofCoords(i,j,k_ind);
// check values
if ( i==j && std::abs( dofValue - 1.0 ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << i << " does not have unit value at its node (" << dofValue <<")\n";
}
if ( i!=j && std::abs( dofValue ) > tol ) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << " Basis function " << i << " does not vanish at node " << j << "(" << dofValue <<")\n";
}
}
}
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\n\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 4: Test correctness of basis function values and curls |\n"
<< "===============================================================================\n";
// VALUE: Each row pair gives the 12x3 correct basis set values at an evaluation point: (P,F,D) layout
const scalar_type basisValues[] = {
1,0,0, 1,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0,
0,0,0, 0,0,0, 1,0,0, 1,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0,
0,0,0, 0,0,0, 0,0,0, 0,0,0, 1,0,0, 1,0,0, 0,0,0, 0,0,0,
0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 1,0,0, 1,0,0,
0,1,0, 0,0,0, 0,1,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0,
0,0,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0,
0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0,
0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,1,0, 0,0,0, 0,1,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,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,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,0, 0,0,1, 0,0,0, 0,0,0, 0,0,0, 0,0,1
};
// CURL
const scalar_type basisCurls[] = {
0,-0.5,0.5, 0,-0.5,0.5, 0,0,0.5, 0,0,0.5, 0,-0.5,0, 0,-0.5,0, 0,0,0, 0,0,0,
0,0,-0.5, 0,0,-0.5, 0,-0.5,-0.5, 0,-0.5,-0.5, 0,0,0, 0,0,0, 0,-0.5,0, 0,-0.5,0,
0,0.5,0, 0,0.5,0, 0,0,0, 0,0,0, 0,0.5,0.5, 0,0.5,0.5, 0,0,0.5, 0,0,0.5,
0,0,0, 0,0,0, 0,0.5,0, 0,0.5,0, 0,0,-0.5, 0,0,-0.5, 0,0.5,-0.5, 0,0.5,-0.5,
// y-component basis functions
// first y-component bf is (0,1/4(1-x)(1-z),0)
// curl is (1/4(1-x),0,-1/4(1-z))
0.5,0,-0.5, 0,0,-0.5, 0.5,0,-0.5, 0,0,-0.5, 0.5,0,0, 0,0,0, 0.5,0,0, 0,0,0,
// second y-component bf is (0,1/4(1+x)(1-z),0)
// curl is (1/4(1+x),0,1/4(1-z))
0,0,0.5, 0.5,0,0.5, 0,0,0.5, 0.5,0,0.5, 0,0,0, 0.5,0,0, 0,0,0, 0.5,0,0,
// third y-component bf is (0,1/4(1-x)(1+z),0)
// curl is (-1/4(1-x),0,-1/4(1+z))
-0.5,0,0, 0,0,0, -0.5,0,0, 0,0,0, -0.5,0,-0.5, 0,0,-0.5, -0.5,0,-0.5, 0,0,-0.5,
// fourth y-component bf is (0,1/4(1+x)(1+z),0)
// curl is (-1/4(1+x),0,1/4(1+z))
0.0,0,0, -0.5,0,0, 0.0,0,0, -0.5,0,0, 0.0,0,0.5, -0.5,0,0.5, 0.0,0,0.5, -0.5,0,0.5,
// first z-component bf is (0,0,1/4(1-x)(1-y))
// curl is (-1/4(1-x),1/4(1-y),0)
-0.5,0.5,0, 0,0.5,0, -0.5,0,0, 0,0,0, -0.5,0.5,0, 0,0.5,0, -0.5,0,0, 0,0,0,
// second z-component bf is (0,0,1/4(1+x)(1-y))
// curl is (-1/4(1+x),1/4(1-y),0)
0.0,-0.5,0, -0.5,-0.5,0, 0,0,0, -0.5,0,0, 0,-0.5,0, -0.5,-0.5,0, 0,0,0, -0.5,0,0,
// third z-component bf is (0,0,1/4(1-x)(1+y))
// curl is (1/4(1-x),1/4(1+y),0)
0.5,0,0, 0,0,0, 0.5,0.5,0, 0,0.5,0, 0.5,0,0, 0,0,0, 0.5,0.5,0, 0,0.5,0,
// fourth z-component bf is (0,0,1/4(1+x)(1+y))
// curl is (1/4(1+x),-1/4(1+y),0)
0,0,0, 0.5,0,0, 0,-0.5,0, 0.5,-0.5,0, 0,0,0, 0.5,0,0, 0,-0.5,0, 0.5,-0.5,0
};
try {
const ordinal_type order = 1;
HexBasisType hexBasis(order);
// Array of reference hex nodes - used for evaluation of basis
DynRankViewHostScalarValueType ConstructWithLabelScalar(hexNodesHost, 8, 3);
DynRankViewPointValueType ConstructWithLabelPointView(hexNodes, 8, 3);
hexNodesHost(0,0) = -1.0; hexNodesHost(0,1) = -1.0; hexNodesHost(0,2) = -1.0;
hexNodesHost(1,0) = 1.0; hexNodesHost(1,1) = -1.0; hexNodesHost(1,2) = -1.0;
hexNodesHost(2,0) = -1.0; hexNodesHost(2,1) = 1.0; hexNodesHost(2,2) = -1.0;
hexNodesHost(3,0) = 1.0; hexNodesHost(3,1) = 1.0; hexNodesHost(3,2) = -1.0;
hexNodesHost(4,0) = -1.0; hexNodesHost(4,1) = -1.0; hexNodesHost(4,2) = 1.0;
hexNodesHost(5,0) = 1.0; hexNodesHost(5,1) = -1.0; hexNodesHost(5,2) = 1.0;
hexNodesHost(6,0) = -1.0; hexNodesHost(6,1) = 1.0; hexNodesHost(6,2) = 1.0;
hexNodesHost(7,0) = 1.0; hexNodesHost(7,1) = 1.0; hexNodesHost(7,2) = 1.0;
auto hexNodes_scalar = Kokkos::create_mirror_view(typename DeviceSpaceType::memory_space(), hexNodesHost);
Kokkos::deep_copy(hexNodes_scalar, hexNodesHost);
RealSpaceTools<DeviceSpaceType>::clone(hexNodes, hexNodes_scalar);
// Array dimensions
const ordinal_type numFields = hexBasis.getCardinality();
const ordinal_type numPoints = hexNodes.extent(0);
const ordinal_type spaceDim = hexBasis.getBaseCellTopology().getDimension();
*outStream << " -- Testing OPERATOR_VALUE \n";
{
// Check VALUE of basis functions
DynRankViewOutValueType ConstructWithLabelOutView(vals, numFields, numPoints, spaceDim);
hexBasis.getValues(vals, hexNodes, OPERATOR_VALUE);
auto vals_host = Kokkos::create_mirror_view(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 * numPoints + j * spaceDim;
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(i,j,k)
<< " but reference value: " << basisValues[l] << "\n";
}
}
}
}
}
*outStream << " -- Testing OPERATOR_CURL \n";
{
// Check CURL of basis function:
DynRankViewOutValueType ConstructWithLabelOutView(curls, numFields, numPoints, spaceDim);
hexBasis.getValues(curls, hexNodes, OPERATOR_CURL);
auto curls_host = Kokkos::create_mirror_view(curls);
Kokkos::deep_copy(curls_host, curls);
for (ordinal_type i = 0; i < numFields; ++i) {
for (ordinal_type j = 0; j < numPoints; ++j) {
for (ordinal_type k = 0; k < spaceDim; k++) {
const ordinal_type l = k + i * spaceDim * numPoints + j * spaceDim;
if (std::abs(curls_host(i,j,k) - basisCurls[l]) > tol) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the curl where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed curl component: " << curls(i,j,k)
<< " but reference curl component: " << basisCurls[l] << "\n";
}
}
}
}
}
} catch (std::exception err) {
*outStream << "UNEXPECTED ERROR !!! ----------------------------------------------------------\n";
*outStream << err.what() << '\n';
*outStream << "-------------------------------------------------------------------------------" << "\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;
}
