void
OrientationTools<SpT>::
init_HGRAD_TET_Cn_FEM(typename OrientationTools<SpT>::CoeffMatrixDataViewType matData,
const ordinal_type order) {
INTREPID2_TEST_FOR_EXCEPTION( true, std::invalid_argument,
">>> ERROR (OrientationTools::init_HGRAD_TET_Cn_FEM): basis is not converted yet to dynrankview." );
}
void
Basis_HCURL_TRI_I1_FEM<SpT,OT,PT>::Internal::
getDofCoords( Kokkos::DynRankView<dofCoordValueType,dofCoordProperties...> dofCoords ) const {
#ifdef HAVE_INTREPID2_DEBUG
// Verify rank of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.rank() != 2, std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HCURL_TRI_I1_FEM::getDofCoords) rank = 2 required for dofCoords array");
// Verify 0th dimension of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.dimension(0) != obj_->basisCardinality_, std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HCURL_TRI_I1_FEM::getDofCoords) mismatch in number of dof and 0th dimension of dofCoords array");
// Verify 1st dimension of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.dimension(1) != obj_->basisCellTopology_.getDimension(), std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HCURL_TRI_I1_FEM::getDofCoords) incorrect reference cell (1st) dimension in dofCoords array");
#endif
Kokkos::deep_copy(dofCoords, obj_->dofCoords_);
}
/** \brief DoF ordinal to DoF tag lookup.
\param dofOrd [in] - ordinal of the DoF whose tag is being retrieved
\return reference to a vector with dimension (4) such that \n
\li element [0] = tag field 0 -> dim. of the subcell associated with the specified DoF
\li element [1] = tag field 1 -> ordinal of the subcell defined by cell topology
\li element [2] = tag field 2 -> ordinal of the specified DoF relative to the subcell
\li element [3] = tag field 3 -> total number of DoFs associated with the subcell
*/
const ordinal_type_array_stride_1d_host
getDofTag( const ordinal_type dofOrd ) const {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( dofOrd < 0 || dofOrd >= static_cast<ordinal_type>(ordinalToTag_.extent(0)), std::out_of_range,
">>> ERROR (Basis::getDofTag): dofOrd is out of range");
#endif
return Kokkos::subview(ordinalToTag_, dofOrd, Kokkos::ALL());
}
/** \brief Evaluation of a FEM basis on a <strong>reference cell</strong>.
Returns values of <var>operatorType</var> acting on FEM basis functions for a set of
points in the <strong>reference cell</strong> for which the basis is defined.
\param outputValues [out] - variable rank array with the basis values
\param inputPoints [in] - rank-2 array (P,D) with the evaluation points
\param operatorType [in] - the operator acting on the basis functions
\remark For rank and dimension specifications of the output array see Section
\ref basis_md_array_sec. Dimensions of <var>ArrayScalar</var> arguments are checked
at runtime if HAVE_INTREPID2_DEBUG is defined.
\remark A FEM basis spans a COMPLETE or INCOMPLETE polynomial space on the reference cell
which is a smooth function space. Thus, all operator types that are meaningful for the
approximated function space are admissible. When the order of the operator exceeds the
degree of the basis, the output array is filled with the appropriate number of zeros.
*/
virtual
void
getValues( outputViewType /* outputValues */,
const pointViewType /* inputPoints */,
const EOperator /* operatorType */ = OPERATOR_VALUE ) const {
INTREPID2_TEST_FOR_EXCEPTION( true, std::logic_error,
">>> ERROR (Basis::getValues): this method (FEM) is not supported or should be over-riden accordingly by derived classes.");
}
ordinal_type compareToAnalytic( std::ifstream &inputFile,
const Kokkos::DynRankView<ValueType,testMatProperties...> testMat,
const ValueType reltol,
const ordinal_type iprint,
const TypeOfExactData analyticDataType ) {
INTREPID2_TEST_FOR_EXCEPTION( testMat.rank() != 2, std::invalid_argument,
">>> ERROR (compareToAnalytic): testMat must have rank 2");
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream outNothing;
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&outNothing, false);
// Save the format state of the original std::cout.
Teuchos::oblackholestream oldFormatState;
oldFormatState.copyfmt(std::cout);
std::string line;
ValueType testentry;
ValueType abstol;
ValueType absdiff;
ordinal_type i = 0, j = 0;
ordinal_type err = 0;
while (! inputFile.eof() && i < static_cast<ordinal_type>(testMat.dimension(0)) ) {
std::getline(inputFile,line);
std::istringstream linestream(line);
std::string chunk;
j = 0;
while( linestream >> chunk ) {
ordinal_type num1;
ordinal_type num2;
std::string::size_type loc = chunk.find( "/", 0);
if( loc != std::string::npos ) {
chunk.replace( loc, 1, " ");
std::istringstream chunkstream(chunk);
chunkstream >> num1;
chunkstream >> num2;
testentry = (ValueType)(num1)/(ValueType)(num2);
abstol = ( std::fabs(testentry) < reltol ? reltol : std::fabs(reltol*testentry) );
absdiff = std::fabs(testentry - testMat(i, j));
if (absdiff > abstol) {
++err;
*outStream << "FAILURE --> ";
}
*outStream << "entry[" << i << "," << j << "]:" << " "
<< testMat(i, j) << " " << num1 << "/" << num2 << " "
<< absdiff << " " << "<?" << " " << abstol << "\n";
}
else {
std::istringstream chunkstream(chunk);
if (analyticDataType == INTREPID2_UTILS_FRACTION) {
chunkstream >> num1;
testentry = (ValueType)(num1);
}
else if (analyticDataType == INTREPID2_UTILS_SCALAR)
void
Basis_HGRAD_LINE_C1_FEM<SpT>::
getDofCoords( Kokkos::DynRankView<dofCoordValueType,dofCoordProperties...> dofCoords ) const {
#ifdef HAVE_INTREPID2_DEBUG
// Verify rank of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.rank() != 2, std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_C1_FEM::getDofCoords) rank = 2 required for dofCoords array");
// Verify 0th dimension of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.dimension(0) != this->basisCardinality_, std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_C1_FEM::getDofCoords) mismatch in number of dof and 0th dimension of dofCoords array");
// Verify 1st dimension of output array.
INTREPID2_TEST_FOR_EXCEPTION( dofCoords.dimension(1) != this->basisCellTopology_.getDimension(), std::invalid_argument,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_C1_FEM::getDofCoords) incorrect reference cell (1st) dimension in dofCoords array");
#endif
dofCoords(0,0) = -1.0;
dofCoords(1,0) = 1.0;
}
void
Basis_HGRAD_LINE_Cn_FEM::
getValues( Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
const Kokkos::DynRankView<vinvValueType, vinvProperties...> vinv,
const EOperator operatorType ) {
typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
typedef Kokkos::DynRankView<vinvValueType, vinvProperties...> vinvViewType;
typedef typename ExecSpace<typename inputPointViewType::execution_space,SpT>::ExecSpaceType ExecSpaceType;
// loopSize corresponds to cardinality
const auto loopSizeTmp1 = (inputPoints.dimension(0)/numPtsPerEval);
const auto loopSizeTmp2 = (inputPoints.dimension(0)%numPtsPerEval != 0);
const auto loopSize = loopSizeTmp1 + loopSizeTmp2;
Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, loopSize);
typedef typename inputPointViewType::value_type inputPointType;
const ordinal_type cardinality = outputValues.dimension(0);
auto vcprop = Kokkos::common_view_alloc_prop(inputPoints);
typedef typename Kokkos::DynRankView< inputPointType, typename inputPointViewType::memory_space> workViewType;
workViewType work(Kokkos::view_alloc("Basis_HGRAD_LINE_Cn_FEM::getValues::work", vcprop), cardinality, inputPoints.dimension(0));
switch (operatorType) {
case OPERATOR_VALUE: {
typedef Functor<outputValueViewType,inputPointViewType,vinvViewType,workViewType,
OPERATOR_VALUE,numPtsPerEval> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
break;
}
case OPERATOR_GRAD:
case OPERATOR_D1:
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10: {
typedef Functor<outputValueViewType,inputPointViewType,vinvViewType,workViewType,
OPERATOR_Dn,numPtsPerEval> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work,
getOperatorOrder(operatorType)) );
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( true , std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Cn_FEM): Operator type not implemented" );
//break; commented out because this always throws
}
}
}
void
PointTools::
getLattice( /**/ Kokkos::DynRankView<pointValueType,pointProperties...> points,
const shards::CellTopology cell,
const ordinal_type order,
const ordinal_type offset,
const EPointType pointType ) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( points.rank() != 2,
std::invalid_argument ,
">>> ERROR (PointTools::getLattice): points rank must be 2." );
INTREPID2_TEST_FOR_EXCEPTION( order < 0 || offset < 0,
std::invalid_argument ,
">>> ERROR (PointTools::getLattice): order and offset must be positive values." );
const size_type latticeSize = getLatticeSize( cell, order, offset );
const size_type spaceDim = cell.getDimension();
INTREPID2_TEST_FOR_EXCEPTION( points.dimension(0) != latticeSize ||
points.dimension(1) != spaceDim,
std::invalid_argument ,
">>> ERROR (PointTools::getLattice): dimension does not match to lattice size." );
#endif
// const auto latticeSize = getLatticeSize( cell, order, offset );
// const auto spaceDim = cell.getDimension();
// // the interface assumes that the input array follows the cell definition
// // so, let's match all dimensions according to the cell specification
// typedef Kokkos::pair<ordinal_type,ordinal_type> range_type;
// auto pts = Kokkos::subview( points,
// range_type(0, latticeSize),
// range_type(0, spaceDim) );
switch (pointType) {
case POINTTYPE_EQUISPACED: getEquispacedLattice( points, cell, order, offset ); break;
case POINTTYPE_WARPBLEND: getWarpBlendLattice ( points, cell, order, offset ); break;
default: {
INTREPID2_TEST_FOR_EXCEPTION( true ,
std::invalid_argument ,
">>> ERROR (PointTools::getLattice): invalid EPointType." );
}
}
}
void
Basis_HGRAD_LINE_C1_FEM<SpT,OT,PT>::Internal::
getValues( /**/ Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
const EOperator operatorType ) const {
#ifdef HAVE_INTREPID2_DEBUG
Intrepid2::getValues_HGRAD_Args(outputValues,
inputPoints,
operatorType,
obj_->getBaseCellTopology(),
obj_->getCardinality() );
#endif
typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
typedef typename ExecSpace<typename inputPointViewType::execution_space,SpT>::ExecSpaceType ExecSpaceType;
// Number of evaluation points = dim 0 of inputPoints
const auto loopSize = inputPoints.dimension(0);
Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, loopSize);
switch (operatorType) {
case OPERATOR_VALUE: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_VALUE> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_GRAD:
case OPERATOR_DIV:
case OPERATOR_CURL:
case OPERATOR_D1: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_GRAD> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_MAX> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( !Intrepid2::isValidOperator(operatorType), std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_C1_FEM): Invalid operator type");
}
}
}
ordinal_type
PointTools::
getLatticeSize( const shards::CellTopology cellType,
const ordinal_type order,
const ordinal_type offset ) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( order < 0 || offset < 0,
std::invalid_argument ,
">>> ERROR (PointTools::getLatticeSize): order and offset must be positive values." );
#endif
ordinal_type r_val = 0;
switch (cellType.getKey()) {
case shards::Tetrahedron<4>::key:
case shards::Tetrahedron<8>::key:
case shards::Tetrahedron<10>::key: {
const auto effectiveOrder = order - 4 * offset;
r_val = (effectiveOrder < 0 ? 0 :(effectiveOrder+1)*(effectiveOrder+2)*(effectiveOrder+3)/6);
break;
}
case shards::Triangle<3>::key:
case shards::Triangle<4>::key:
case shards::Triangle<6>::key: {
const auto effectiveOrder = order - 3 * offset;
r_val = (effectiveOrder < 0 ? 0 : (effectiveOrder+1)*(effectiveOrder+2)/2);
break;
}
case shards::Line<2>::key:
case shards::Line<3>::key: {
const auto effectiveOrder = order - 2 * offset;
r_val = (effectiveOrder < 0 ? 0 : (effectiveOrder+1));
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( true , std::invalid_argument ,
">>> ERROR (Intrepid2::PointTools::getLatticeSize): the specified cell type is not supported." );
}
}
return r_val;
}
/** \brief DoF tag to ordinal lookup.
\param subcDim [in] - tag field 0: dimension of the subcell associated with the DoF
\param subcOrd [in] - tag field 1: ordinal of the subcell defined by cell topology
\param subcDofOrd [in] - tag field 2: ordinal of the DoF relative to the subcell.
\return the DoF ordinal corresponding to the specified DoF tag data.
*/
ordinal_type
getDofOrdinal( const ordinal_type subcDim,
const ordinal_type subcOrd,
const ordinal_type subcDofOrd ) const {
// this should be abort and able to be called as a device function
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( subcDim < 0 || subcDim >= static_cast<ordinal_type>(tagToOrdinal_.extent(0)), std::out_of_range,
">>> ERROR (Basis::getDofOrdinal): subcDim is out of range");
INTREPID2_TEST_FOR_EXCEPTION( subcOrd < 0 || subcOrd >= static_cast<ordinal_type>(tagToOrdinal_.extent(1)), std::out_of_range,
">>> ERROR (Basis::getDofOrdinal): subcOrd is out of range");
INTREPID2_TEST_FOR_EXCEPTION( subcDofOrd < 0 || subcDofOrd >= static_cast<ordinal_type>(tagToOrdinal_.extent(2)), std::out_of_range,
">>> ERROR (Basis::getDofOrdinal): subcDofOrd is out of range");
#endif
ordinal_type r_val = -1;
if ( subcDim < static_cast<ordinal_type>(tagToOrdinal_.extent(0)) &&
subcOrd < static_cast<ordinal_type>(tagToOrdinal_.extent(1)) &&
subcDofOrd < static_cast<ordinal_type>(tagToOrdinal_.extent(2)) )
r_val = tagToOrdinal_(subcDim, subcOrd, subcDofOrd);
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( r_val == -1, std::runtime_error,
">>> ERROR (Basis::getDofOrdinal): Invalid DoF tag is found.");
#endif
return r_val;
}
void PointTools::
getWarpBlendLattice( /**/ Kokkos::DynRankView<pointValueType,pointProperties...> points,
const shards::CellTopology cell,
const ordinal_type order,
const ordinal_type offset ) {
switch (cell.getBaseKey()) {
// case shards::Tetrahedron<>::key: getWarpBlendLatticeTetrahedron( points, order, offset ); break;
// case shards::Triangle<>::key: getWarpBlendLatticeTriangle ( points, order, offset ); break;
case shards::Line<>::key: getWarpBlendLatticeLine ( points, order, offset ); break;
default: {
INTREPID2_TEST_FOR_EXCEPTION( true , std::invalid_argument ,
">>> ERROR (Intrepid2::PointTools::getWarpBlendLattice): the specified cell type is not supported." );
}
}
}
typename OrientationTools<SpT>::CoeffMatrixDataViewType
OrientationTools<SpT>::createCoeffMatrix(BasisPtrType basis) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( !basis->requireOrientation(), std::invalid_argument,
">>> ERROR (OrientationTools::createCoeffMatrix): basis does not require orientations." );
#endif
const std::pair<std::string,int> key(basis->getName(), basis->getDegree());
const auto found = ortCoeffData.find(key);
CoeffMatrixDataViewType matData;
if (found == ortCoeffData.end()) {
matData = createCoeffMatrixInternal(basis);
ortCoeffData.insert(std::make_pair(key, matData));
} else {
matData = found->second;
}
return matData;
}
void
OrientationTools<SpT>::
modifyBasisByOrientation(/**/ Kokkos::DynRankView<outputValueType,outputProperties...> output,
const Kokkos::DynRankView<inputValueType, inputProperties...> input,
const Kokkos::DynRankView<ortValueType, ortProperties...> orts,
const BasisPtrType basis ) {
#ifdef HAVE_INTREPID2_DEBUG
{
INTREPID2_TEST_FOR_EXCEPTION( input.rank() != output.rank(), std::invalid_argument,
">>> ERROR (OrientationTools::modifyBasisByOrientation): Input and output rank are not 3.");
for (ordinal_type i=0;i<input.rank();++i)
INTREPID2_TEST_FOR_EXCEPTION( input.dimension(i) != output.dimension(i), std::invalid_argument,
">>> ERROR (OrientationTools::modifyBasisByOrientation): Input and output dimension does not match.");
INTREPID2_TEST_FOR_EXCEPTION( input.dimension(1) != basis->getCardinality(), std::invalid_argument,
">>> ERROR (OrientationTools::modifyBasisByOrientation): Field dimension of input/output does not match to basis cardinality.");
INTREPID2_TEST_FOR_EXCEPTION( input.dimension(3) != basis->getBaseCellTopology().getDimension(), std::invalid_argument,
">>> ERROR (OrientationTools::modifyBasisByOrientation): Space dimension of input/output does not match to topology dimension.");
}
#endif
if (basis->requireOrientation()) {
auto ordinalToTag = Kokkos::create_mirror_view(typename SpT::memory_space(), basis->getAllDofTags());
auto tagToOrdinal = Kokkos::create_mirror_view(typename SpT::memory_space(), basis->getAllDofOrdinal());
Kokkos::deep_copy(ordinalToTag, basis->getAllDofTags());
Kokkos::deep_copy(tagToOrdinal, basis->getAllDofOrdinal());
const ordinal_type
numCells = output.dimension(0),
//numBasis = output.dimension(1),
numPoints = output.dimension(2),
dimBasis = output.dimension(3);
const CoeffMatrixDataViewType matData = createCoeffMatrix(basis);
const shards::CellTopology cellTopo = basis->getBaseCellTopology();
const ordinal_type
numVerts = cellTopo.getVertexCount(),
numEdges = cellTopo.getEdgeCount(),
numFaces = cellTopo.getFaceCount();
const ordinal_type intrDim = ( numEdges == 0 ? 1 :
numFaces == 0 ? 2 :
/**/ 3 );
for (auto cell=0;cell<numCells;++cell) {
auto out = Kokkos::subview(output, cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
auto in = Kokkos::subview(input, cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
// vertex copy (no orientation)
for (auto vertId=0;vertId<numVerts;++vertId) {
const auto i = tagToOrdinal(0, vertId, 0);
if (i != -1) // if dof does not exist i returns with -1
for (auto j=0;j<numPoints;++j)
for (auto k=0;k<dimBasis;++k)
out(i, j, k) = in(i, j, k);
}
// interior copy
{
const auto ordIntr = tagToOrdinal(intrDim, 0, 0);
if (ordIntr != -1) {
const auto ndofIntr = ordinalToTag(ordIntr, 3);
for (auto i=0;i<ndofIntr;++i) {
const auto ii = tagToOrdinal(intrDim, 0, i);
for (auto j=0;j<numPoints;++j)
for (auto k=0;k<dimBasis;++k)
out(ii, j, k) = in(ii, j, k);
}
}
}
// edge transformation
if (numEdges > 0) {
ordinal_type ortEdges[12];
orts(cell).getEdgeOrientation(ortEdges, numEdges);
// apply coeff matrix
for (auto edgeId=0;edgeId<numEdges;++edgeId) {
const auto ordEdge = tagToOrdinal(1, edgeId, 0);
if (ordEdge != -1) {
const auto ndofEdge = ordinalToTag(ordEdge, 3);
const auto mat = Kokkos::subview(matData,
edgeId, ortEdges[edgeId],
Kokkos::ALL(), Kokkos::ALL());
for (auto j=0;j<numPoints;++j)
for (auto i=0;i<ndofEdge;++i) {
const auto ii = tagToOrdinal(1, edgeId, i);
for (auto k=0;k<dimBasis;++k) {
double temp = 0.0;
for (auto l=0;l<ndofEdge;++l) {
const auto ll = tagToOrdinal(1, edgeId, l);
temp += mat(i,l)*in(ll, j, k);
}
out(ii, j, k) = temp;
}
}
}
}
}
// face transformation
if (numFaces > 0) {
ordinal_type ortFaces[12];
orts(cell).getFaceOrientation(ortFaces, numFaces);
// apply coeff matrix
for (auto faceId=0;faceId<numFaces;++faceId) {
const auto ordFace = tagToOrdinal(2, faceId, 0);
if (ordFace != -1) {
const auto ndofFace = ordinalToTag(ordFace, 3);
const auto mat = Kokkos::subview(matData,
numEdges+faceId, ortFaces[faceId],
Kokkos::ALL(), Kokkos::ALL());
for (auto j=0;j<numPoints;++j)
for (auto i=0;i<ndofFace;++i) {
const auto ii = tagToOrdinal(2, faceId, i);
for (auto k=0;k<dimBasis;++k) {
double temp = 0.0;
for (auto l=0;l<ndofFace;++l) {
const auto ll = tagToOrdinal(2, faceId, l);
temp += mat(i,l)*in(ll, j, k);
}
out(ii, j, k) = temp;
}
}
}
}
}
}
} else {
Kokkos::deep_copy(output, input);
}
}
Basis_HGRAD_LINE_Cn_FEM<SpT,OT,PT>::
Basis_HGRAD_LINE_Cn_FEM( const ordinal_type order,
const EPointType pointType ) {
this->basisCardinality_ = order+1;
this->basisDegree_ = order;
this->basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >() );
this->basisType_ = BASIS_FEM_FIAT;
this->basisCoordinates_ = COORDINATES_CARTESIAN;
const ordinal_type card = this->basisCardinality_;
// points are computed in the host and will be copied
Kokkos::DynRankView<typename scalarViewType::value_type,typename SpT::array_layout,Kokkos::HostSpace>
dofCoords("Hgrad::Line::Cn::dofCoords", card, 1);
switch (pointType) {
case POINTTYPE_EQUISPACED:
case POINTTYPE_WARPBLEND: {
// lattice ordering
{
const ordinal_type offset = 0;
PointTools::getLattice( dofCoords,
this->basisCellTopology_,
order, offset,
pointType );
}
// topological order
// {
// // two vertices
// dofCoords(0,0) = -1.0;
// dofCoords(1,0) = 1.0;
// // internal points
// typedef Kokkos::pair<ordinal_type,ordinal_type> range_type;
// auto pts = Kokkos::subview(dofCoords, range_type(2, card), Kokkos::ALL());
// const auto offset = 1;
// PointTools::getLattice( pts,
// this->basisCellTopology_,
// order, offset,
// pointType );
// }
break;
}
case POINTTYPE_GAUSS: {
// internal points only
PointTools::getGaussPoints( dofCoords,
order );
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( !isValidPointType(pointType),
std::invalid_argument ,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_Cn_FEM) invalid pointType." );
}
}
this->dofCoords_ = Kokkos::create_mirror_view(typename SpT::memory_space(), dofCoords);
Kokkos::deep_copy(this->dofCoords_, dofCoords);
// form Vandermonde matrix; actually, this is the transpose of the VDM,
// this matrix is used in LAPACK so it should be column major and left layout
const ordinal_type lwork = card*card;
Kokkos::DynRankView<typename scalarViewType::value_type,Kokkos::LayoutLeft,Kokkos::HostSpace>
vmat("Hgrad::Line::Cn::vmat", card, card),
work("Hgrad::Line::Cn::work", lwork),
ipiv("Hgrad::Line::Cn::ipiv", card);
const double alpha = 0.0, beta = 0.0;
Impl::Basis_HGRAD_LINE_Cn_FEM_JACOBI::
getValues<Kokkos::HostSpace::execution_space,Parameters::MaxNumPtsPerBasisEval>
(vmat, dofCoords, order, alpha, beta, OPERATOR_VALUE);
ordinal_type info = 0;
Teuchos::LAPACK<ordinal_type,typename scalarViewType::value_type> lapack;
lapack.GETRF(card, card,
vmat.data(), vmat.stride_1(),
(ordinal_type*)ipiv.data(),
&info);
INTREPID2_TEST_FOR_EXCEPTION( info != 0,
std::runtime_error ,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_Cn_FEM) lapack.GETRF returns nonzero info." );
lapack.GETRI(card,
vmat.data(), vmat.stride_1(),
(ordinal_type*)ipiv.data(),
work.data(), lwork,
&info);
INTREPID2_TEST_FOR_EXCEPTION( info != 0,
std::runtime_error ,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_Cn_FEM) lapack.GETRI returns nonzero info." );
// create host mirror
Kokkos::DynRankView<typename scalarViewType::value_type,typename SpT::array_layout,Kokkos::HostSpace>
vinv("Hgrad::Line::Cn::vinv", card, card);
for (ordinal_type i=0;i<card;++i)
for (ordinal_type j=0;j<card;++j)
vinv(i,j) = vmat(j,i);
this->vinv_ = Kokkos::create_mirror_view(typename SpT::memory_space(), vinv);
Kokkos::deep_copy(this->vinv_ , vinv);
// initialize tags
{
const bool is_vertex_included = (pointType != POINTTYPE_GAUSS);
// Basis-dependent initializations
const ordinal_type tagSize = 4; // size of DoF tag, i.e., number of fields in the tag
const ordinal_type posScDim = 0; // position in the tag, counting from 0, of the subcell dim
const ordinal_type posScOrd = 1; // position in the tag, counting from 0, of the subcell ordinal
const ordinal_type posDfOrd = 2; // position in the tag, counting from 0, of DoF ordinal relative to the subcell
ordinal_type tags[Parameters::MaxOrder+1][4];
// now we check the points for association
if (is_vertex_included) {
// lattice order
{
const auto v0 = 0;
tags[v0][0] = 0; // vertex dof
tags[v0][1] = 0; // vertex id
tags[v0][2] = 0; // local dof id
tags[v0][3] = 1; // total number of dofs in this vertex
const ordinal_type iend = card - 2;
for (ordinal_type i=0;i<iend;++i) {
const auto e = i + 1;
tags[e][0] = 1; // edge dof
tags[e][1] = 0; // edge id
tags[e][2] = i; // local dof id
tags[e][3] = iend; // total number of dofs in this edge
}
const auto v1 = card -1;
tags[v1][0] = 0; // vertex dof
tags[v1][1] = 1; // vertex id
tags[v1][2] = 0; // local dof id
tags[v1][3] = 1; // total number of dofs in this vertex
}
// topological order
// {
// tags[0][0] = 0; // vertex dof
// tags[0][1] = 0; // vertex id
// tags[0][2] = 0; // local dof id
// tags[0][3] = 1; // total number of dofs in this vertex
// tags[1][0] = 0; // vertex dof
// tags[1][1] = 1; // vertex id
// tags[1][2] = 0; // local dof id
// tags[1][3] = 1; // total number of dofs in this vertex
// const ordinal_type iend = card - 2;
// for (ordinal_type i=0;i<iend;++i) {
// const auto ii = i + 2;
// tags[ii][0] = 1; // edge dof
// tags[ii][1] = 0; // edge id
// tags[ii][2] = i; // local dof id
// tags[ii][3] = iend; // total number of dofs in this edge
// }
// }
} else {
for (ordinal_type i=0;i<card;++i) {
tags[i][0] = 1; // edge dof
tags[i][1] = 0; // edge id
tags[i][2] = i; // local dof id
tags[i][3] = card; // total number of dofs in this edge
}
}
ordinal_type_array_1d_host tagView(&tags[0][0], card*4);
// Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
// tags are constructed on host
this->setOrdinalTagData(this->tagToOrdinal_,
this->ordinalToTag_,
tagView,
this->basisCardinality_,
tagSize,
posScDim,
posScOrd,
posDfOrd);
}
}
void
ArrayTools<ExecSpaceType>::
scalarMultiplyDataData( /**/ Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight,
const bool reciprocal ) {
#ifdef HAVE_INTREPID2_DEBUG
{
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.rank() != 2, std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Left input data container must have rank 2.");
if (outputData.rank() <= inputDataRight.rank()) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() < 2 || inputDataRight.rank() > 4, std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input data container must have rank 2, 3, or 4.");
INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != inputDataRight.rank(), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input and output data containers must have the same rank.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.dimension(0) != inputDataLeft.dimension(0), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimensions (number of integration domains) of the left and right data input containers must agree!");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(1) != inputDataRight.dimension(1) &&
inputDataLeft.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): First dimensions of the left and right data input containers (number of integration points) must agree, or first dimension of the left data input container must be 1!");
for (size_type i=0;i<inputDataRight.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.dimension(i) != outputData.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): inputDataRight dimension (i) does not match to the dimension (i) of outputData");
}
} else {
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() < 1 || inputDataRight.rank() > 3, std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Right input data container must have rank 1, 2, or 3.");
INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != (inputDataRight.rank()+1), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): The rank of the right input data container must be one less than the rank of the output data container.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(1) != inputDataRight.dimension(0) &&
inputDataLeft.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimension of the right input data container and first dimension of the left data input container (number of integration points) must agree or first dimension of the left data input container must be 1!");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(0) != outputData.dimension(0), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): Zeroth dimensions of data output and left data input containers (number of integration domains) must agree!");
for (size_type i=0;i<inputDataRight.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.dimension(i) != outputData.dimension(i+1), std::invalid_argument,
">>> ERROR (ArrayTools::scalarMultiplyDataData): inputDataRight dimension (i) does not match to the dimension (i+1) of outputData");
}
}
}
#endif
// body
ArrayTools<ExecSpaceType>::Internal::scalarMultiply( outputData,
inputDataLeft,
inputDataRight,
false,
reciprocal );
}
void
Basis_HGRAD_HEX_C1_FEM::
getValues( /**/ Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
const EOperator operatorType ) {
typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
typedef typename ExecSpace<typename inputPointViewType::execution_space,SpT>::ExecSpaceType ExecSpaceType;
// Number of evaluation points = dim 0 of inputPoints
const auto loopSize = inputPoints.dimension(0);
Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, loopSize);
switch (operatorType) {
case OPERATOR_VALUE: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_VALUE> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_GRAD:
case OPERATOR_D1: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_GRAD> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_CURL: {
INTREPID2_TEST_FOR_EXCEPTION( operatorType == OPERATOR_CURL, std::invalid_argument,
">>> ERROR (Basis_HGRAD_HEX_C1_FEM): CURL is invalid operator for rank-0 (scalar) functions in 3D");
break;
}
case OPERATOR_DIV: {
INTREPID2_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument,
">>> ERROR (Basis_HGRAD_HEX_C1_FEM): DIV is invalid operator for rank-0 (scalar) functions in 3D");
break;
}
case OPERATOR_D2: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_D2> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_MAX> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( !( Intrepid2::isValidOperator(operatorType) ), std::invalid_argument,
">>> ERROR (Basis_HGRAD_HEX_C1_FEM): Invalid operator type");
}
}
}
void
Basis_HDIV_TRI_I1_FEM::
getValues( Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
const EOperator operatorType ) {
typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
typedef typename ExecSpace<typename inputPointViewType::execution_space,SpT>::ExecSpaceType ExecSpaceType;
// Number of evaluation points = dim 0 of inputPoints
const auto loopSize = inputPoints.dimension(0);
Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, loopSize);
switch (operatorType) {
case OPERATOR_VALUE: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_VALUE> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_DIV: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_DIV> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints) );
break;
}
case OPERATOR_CURL: {
INTREPID2_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_CURL), std::invalid_argument,
">>> ERROR (Basis_HDIV_TRI_I1_FEM): CURL is invalid operator for HDIV Basis Functions");
break;
}
case OPERATOR_GRAD: {
INTREPID2_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
">>> ERROR (Basis_HDIV_TRI_I1_FEM): GRAD is invalid operator for HDIV Basis Functions");
break;
}
case OPERATOR_D1:
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10: {
INTREPID2_TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1) &&
(operatorType == OPERATOR_D2) &&
(operatorType == OPERATOR_D3) &&
(operatorType == OPERATOR_D4) &&
(operatorType == OPERATOR_D5) &&
(operatorType == OPERATOR_D6) &&
(operatorType == OPERATOR_D7) &&
(operatorType == OPERATOR_D8) &&
(operatorType == OPERATOR_D9) &&
(operatorType == OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HDIV_TRI_I1_FEM): Invalid operator type");
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
(operatorType != OPERATOR_GRAD) &&
(operatorType != OPERATOR_CURL) &&
(operatorType != OPERATOR_DIV) &&
(operatorType != OPERATOR_D1) &&
(operatorType != OPERATOR_D2) &&
(operatorType != OPERATOR_D3) &&
(operatorType != OPERATOR_D4) &&
(operatorType != OPERATOR_D5) &&
(operatorType != OPERATOR_D6) &&
(operatorType != OPERATOR_D7) &&
(operatorType != OPERATOR_D8) &&
(operatorType != OPERATOR_D9) &&
(operatorType != OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HDIV_TRI_I1_FEM): Invalid operator type");
}
}
}
void
CubatureTensor<SpT,PT,WT>::
getCubatureImpl( Kokkos::DynRankView<cubPointValueType, cubPointProperties...> cubPoints,
Kokkos::DynRankView<cubWeightValueType,cubWeightProperties...> cubWeights ) const {
#ifdef HAVE_INTREPID2_DEBUG
// check size of cubPoints and cubWeights
INTREPID2_TEST_FOR_EXCEPTION( static_cast<ordinal_type>(cubPoints.dimension(0)) < this->getNumPoints() ||
static_cast<ordinal_type>(cubPoints.dimension(1)) < this->getDimension() ||
static_cast<ordinal_type>(cubWeights.dimension(0)) < this->getNumPoints(), std::out_of_range,
">>> ERROR (CubatureTensor): Insufficient space allocated for cubature points or weights.");
#endif
typedef Kokkos::DynRankView<cubPointValueType, SpT> cubPointViewType;
typedef Kokkos::DynRankView<cubWeightValueType,SpT> cubWeightViewType;
// mirroring and where the data is problematic... when it becomes a problem, then deal with it.
cubPointViewType tmpPoints [Parameters::MaxDimension];
cubWeightViewType tmpWeights[Parameters::MaxDimension];
// this temporary allocation can be member of cubature; for now, let's do this way.
// this is cubature setup on the reference cell and called for tensor elements.
for (auto k=0;k<this->numCubatures_;++k) {
const auto &cub = this->cubatures_[k];
tmpPoints [k] = cubPointViewType ("CubatureTensor::getCubature::tmpPoints", cub.getNumPoints(), cub.getDimension());
tmpWeights[k] = cubWeightViewType("CubatureTensor::getCubature::tmpWeights", cub.getNumPoints());
cub.getCubature(tmpPoints[k], tmpWeights[k]);
}
{
const auto npts = this->getNumPoints();
const auto dim = this->getDimension();
const Kokkos::pair<ordinal_type,ordinal_type> pointRange(0, npts);
const Kokkos::pair<ordinal_type,ordinal_type> dimRange(0, dim);
Kokkos::deep_copy(Kokkos::subdynrankview(cubPoints, pointRange, dimRange), 0.0);
Kokkos::deep_copy(Kokkos::subdynrankview(cubWeights, pointRange), 1.0);
}
// when the input containers are device space, this is better computed on host and copy to devices
// fill tensor cubature
{
ordinal_type offset[Parameters::MaxDimension+1] = {};
for (auto k=0;k<this->numCubatures_;++k) {
offset[k+1] = offset[k] + this->cubatures_[k].getDimension();
}
ordinal_type ii = 0, i[3] = {};
switch (this->numCubatures_) {
case 2: {
const ordinal_type npts[] = { this->cubatures_[0].getNumPoints(), this->cubatures_[1].getNumPoints() };
const ordinal_type dim [] = { this->cubatures_[0].getDimension(), this->cubatures_[1].getDimension() };
for (i[1]=0;i[1]<npts[1];++i[1])
for (i[0]=0;i[0]<npts[0];++i[0]) {
for (auto nc=0;nc<2;++nc) {
cubWeights(ii) *= tmpWeights[nc](i[nc]);
for (ordinal_type j=0;j<dim[nc];++j)
cubPoints(ii, offset[nc]+j) = tmpPoints[nc](i[nc], j);
}
++ii;
}
break;
}
case 3: {
const ordinal_type npts[] = { this->cubatures_[0].getNumPoints(), this->cubatures_[1].getNumPoints(), this->cubatures_[2].getNumPoints() };
const ordinal_type dim [] = { this->cubatures_[0].getDimension(), this->cubatures_[1].getDimension(), this->cubatures_[2].getDimension() };
for (i[2]=0;i[2]<npts[2];++i[2])
for (i[1]=0;i[1]<npts[1];++i[1])
for (i[0]=0;i[0]<npts[0];++i[0]) {
for (auto nc=0;nc<3;++nc) {
cubWeights(ii) *= tmpWeights[nc](i[nc]);
for (ordinal_type j=0;j<dim[nc];++j)
cubPoints(ii, offset[nc]+j) = tmpPoints[nc](i[nc], j);
}
++ii;
}
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( this->numCubatures_ != 2 || this->numCubatures_ != 3, std::runtime_error,
">>> ERROR (CubatureTensor::getCubature): CubatureTensor supports only 2 or 3 component direct cubatures.");
}
}
}
}
void
CellTools<SpT>::
mapToReferenceSubcell( /**/ Kokkos::DynRankView<refSubcellPointValueType,refSubcellPointProperties...> refSubcellPoints,
const Kokkos::DynRankView<paramPointValueType,paramPointProperties...> paramPoints,
const ordinal_type subcellDim,
const ordinal_type subcellOrd,
const shards::CellTopology parentCell ) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( !hasReferenceCell(parentCell), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): the specified cell topology does not have a reference cell.");
INTREPID2_TEST_FOR_EXCEPTION( subcellDim != 1 &&
subcellDim != 2, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): method defined only for 1 and 2-dimensional subcells.");
INTREPID2_TEST_FOR_EXCEPTION( subcellOrd < 0 ||
subcellOrd >= parentCell.getSubcellCount(subcellDim), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): subcell ordinal out of range.");
// refSubcellPoints is rank-2 (P,D1), D1 = cell dimension
INTREPID2_TEST_FOR_EXCEPTION( refSubcellPoints.rank() != 2, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): refSubcellPoints must have rank 2.");
INTREPID2_TEST_FOR_EXCEPTION( refSubcellPoints.dimension(1) != parentCell.getDimension(), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): refSubcellPoints dimension (1) does not match to parent cell dimension.");
// paramPoints is rank-2 (P,D2) with D2 = subcell dimension
INTREPID2_TEST_FOR_EXCEPTION( paramPoints.rank() != 2, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): paramPoints must have rank 2.");
INTREPID2_TEST_FOR_EXCEPTION( paramPoints.dimension(1) != subcellDim, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): paramPoints dimension (1) does not match to subcell dimension.");
// cross check: refSubcellPoints and paramPoints: dimension 0 must match
INTREPID2_TEST_FOR_EXCEPTION( refSubcellPoints.dimension(0) < paramPoints.dimension(0), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): refSubcellPoints dimension (0) does not match to paramPoints dimension(0).");
#endif
const auto cellDim = parentCell.getDimension();
const auto numPts = paramPoints.dimension(0);
// Get the subcell map, i.e., the coefficients of the parametrization function for the subcell
// can i get this map from devices ?
subcellParamViewType subcellMap;
getSubcellParametrization( subcellMap,
subcellDim,
parentCell );
// subcell parameterization should be small computation (numPts is small) and it should be decorated with
// kokkos inline... let's not do this yet
// Apply the parametrization map to every point in parameter domain
switch (subcellDim) {
case 2: {
for (size_type pt=0;pt<numPts;++pt) {
const auto u = paramPoints(pt, 0);
const auto v = paramPoints(pt, 1);
// map_dim(u,v) = c_0(dim) + c_1(dim)*u + c_2(dim)*v because both Quad and Tri ref faces are affine!
for (size_type i=0;i<cellDim;++i)
refSubcellPoints(pt, i) = subcellMap(subcellOrd, i, 0) + ( subcellMap(subcellOrd, i, 1)*u +
subcellMap(subcellOrd, i, 2)*v );
}
break;
}
case 1: {
for (size_type pt=0;pt<numPts;++pt) {
const auto u = paramPoints(pt, 0);
for (size_type i=0;i<cellDim;++i)
refSubcellPoints(pt, i) = subcellMap(subcellOrd, i, 0) + ( subcellMap(subcellOrd, i, 1)*u );
}
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( subcellDim != 1 &&
subcellDim != 2, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::mapToReferenceSubcell): method defined only for 1 and 2-subcells");
}
}
}
void
CellTools<SpT>::
getSubcellParametrization( subcellParamViewType &subcellParam,
const ordinal_type subcellDim,
const shards::CellTopology parentCell ) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( !hasReferenceCell(parentCell), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::getSubcellParametrization): the specified cell topology does not have a reference cell.");
#endif
if (!isSubcellParametrizationSet_)
setSubcellParametrization();
// Select subcell parametrization according to its parent cell type
const auto pcd = parentCell.getDimension(); // parent cell dim
INTREPID2_TEST_FOR_EXCEPTION( subcellDim < 1 || subcellDim > static_cast<ordinal_type>(pcd-1), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::getSubcellParametrization): Parametrizations defined in a range between 1 and (dim-1)");
switch (parentCell.getKey() ) {
case shards::Tetrahedron<4>::key:
case shards::Tetrahedron<8>::key:
case shards::Tetrahedron<10>::key:
case shards::Tetrahedron<11>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.tetFaces : subcellParamData_.tetEdges ); break;
case shards::Hexahedron<8>::key:
case shards::Hexahedron<20>::key:
case shards::Hexahedron<27>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.hexFaces : subcellParamData_.hexEdges ); break;
case shards::Pyramid<5>::key:
case shards::Pyramid<13>::key:
case shards::Pyramid<14>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.pyrFaces : subcellParamData_.pyrEdges ); break;
case shards::Wedge<6>::key:
case shards::Wedge<15>::key:
case shards::Wedge<18>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.wedgeFaces : subcellParamData_.wedgeEdges ); break;
case shards::Triangle<3>::key:
case shards::Triangle<4>::key:
case shards::Triangle<6>::key: subcellParam = subcellParamData_.triEdges; break;
case shards::Quadrilateral<4>::key:
case shards::Quadrilateral<8>::key:
case shards::Quadrilateral<9>::key: subcellParam = subcellParamData_.quadEdges; break;
// case shards::ShellTriangle<3>::key:
// case shards::ShellTriangle<6>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.shellTriFaces : subcellParamData_.shellTriEdges ); break;
// case shards::ShellQuadrilateral<4>::key:
// case shards::ShellQuadrilateral<8>::key:
// case shards::ShellQuadrilateral<9>::key: subcellParam = ( subcellDim == 2 ? subcellParamData_.shellQuadFaces : subcellParamData_.shellQuadEdges ); break;
case shards::ShellLine<2>::key:
case shards::ShellLine<3>::key:
case shards::Beam<2>::key:
case shards::Beam<3>::key: subcellParam = subcellParamData_.lineEdges; break;
default: {
INTREPID2_TEST_FOR_EXCEPTION( true, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::getSubcellParametrization): invalid cell topology.");
}
}
}
int Integration_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 (CubatureDirect,CubatureTensor) |\n"
<< "| |\n"
<< "| 1) Computing volumes of reference cells |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]) or |\n"
<< "| Denis Ridzal ([email protected]) or |\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;
#define ConstructWithLabel(obj, ...) obj(#obj, __VA_ARGS__)
typedef ValueType pointValueType;
typedef ValueType weightValueType;
typedef CubatureDirectLineGauss <DeviceSpaceType,pointValueType,weightValueType> CubatureLineType;
typedef CubatureDirectLineGaussJacobi20<DeviceSpaceType,pointValueType,weightValueType> CubatureLineJacobiType;
typedef CubatureDirectTriDefault <DeviceSpaceType,pointValueType,weightValueType> CubatureTriType;
typedef CubatureDirectTetDefault <DeviceSpaceType,pointValueType,weightValueType> CubatureTetType;
typedef CubatureTensor <DeviceSpaceType,pointValueType,weightValueType> CubatureTensorType;
typedef CubatureTensorPyr <DeviceSpaceType,pointValueType,weightValueType> CubatureTensorPyrType;
const auto tol = 100.0 * tolerence();
int errorFlag = 0;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: exception |\n"
<< "===============================================================================\n";
try {
ordinal_type nthrow = 0, ncatch = 0;
#ifdef HAVE_INTREPID2_DEBUG
*outStream << "-> Line testing\n\n";
{
INTREPID2_TEST_ERROR_EXPECTED( CubatureLineType(-1) );
INTREPID2_TEST_ERROR_EXPECTED( CubatureLineType(Parameters::MaxCubatureDegreeEdge+1) );
}
*outStream << "-> Triangle testing\n\n";
{
INTREPID2_TEST_ERROR_EXPECTED( CubatureTriType triCub(-1) );
INTREPID2_TEST_ERROR_EXPECTED( CubatureTriType triCub(Parameters::MaxCubatureDegreeTri+1) );
}
*outStream << "-> Tetrahedron testing\n\n";
{
INTREPID2_TEST_ERROR_EXPECTED( CubatureTetType tetCub(-1) );
INTREPID2_TEST_ERROR_EXPECTED( CubatureTetType tetCub(Parameters::MaxCubatureDegreeTet+1) );
}
#endif
if (nthrow != ncatch) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
*outStream << "# of catch ("<< ncatch << ") is different from # of throw (" << ncatch << ")\n";
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
};
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 2: basic functionalities |\n"
<< "===============================================================================\n";
try {
*outStream << "-> Line testing\n\n";
{
CubatureLineType lineCub(4);
INTREPID2_TEST_FOR_EXCEPTION( lineCub.getDimension() != 1, std::logic_error,
">>> ERROR (Integration::Test01): line cubature must have 1 dimension.");
INTREPID2_TEST_FOR_EXCEPTION( lineCub.getAccuracy() != 4, std::logic_error,
">>> ERROR (Integration::Test01): line cubature reports wrong accuracy.");
}
*outStream << "-> Triangle testing\n\n";
{
CubatureTriType triCub(17);
INTREPID2_TEST_FOR_EXCEPTION( triCub.getNumPoints() != 61, std::logic_error,
">>> ERROR (Integration::Test01): triangle cubature reports a wrong number of points.");
INTREPID2_TEST_FOR_EXCEPTION( triCub.getDimension() != 2, std::logic_error,
">>> ERROR (Integration::Test01): triangle cubature reports a wrong dimension.");
}
*outStream << "-> Tetrahedron testing\n\n";
{
CubatureTetType tetCub(17);
INTREPID2_TEST_FOR_EXCEPTION( tetCub.getNumPoints() != 495, std::logic_error,
">>> ERROR (Integration::Test01): tetrahedron cubature reports a wrong number of points.");
INTREPID2_TEST_FOR_EXCEPTION( tetCub.getDimension() != 3, std::logic_error,
">>> ERROR (Integration::Test01): tetrahedron cubature reports a wrong dimension.");
}
*outStream << "-> Quad testing\n\n";
{
CubatureTensorType quadCub( CubatureLineType(3), CubatureLineType(7) );
INTREPID2_TEST_FOR_EXCEPTION( quadCub.getDimension() != 2, std::logic_error,
">>> ERROR (Integration::Test01): quad cubature must have 2 dimension.");
ordinal_type accuracy[Parameters::MaxDimension];
quadCub.getAccuracy( accuracy );
INTREPID2_TEST_FOR_EXCEPTION( accuracy[0] != 3 || accuracy[1] != 7, std::logic_error,
">>> ERROR (Integration::Test01): quad cubature reports wrong accuracy.");
}
*outStream << "-> Hex testing\n\n";
{
CubatureTensorType hexCub( CubatureLineType(1), CubatureLineType(4), CubatureLineType(2) );
INTREPID2_TEST_FOR_EXCEPTION( hexCub.getDimension() != 3, std::logic_error,
">>> ERROR (Integration::Test01): hex cubature must have 3 dimension.");
ordinal_type accuracy[Parameters::MaxDimension];
hexCub.getAccuracy( accuracy );
INTREPID2_TEST_FOR_EXCEPTION( accuracy[0] != 1 || accuracy[1] != 4 || accuracy[2] != 2, std::logic_error,
">>> ERROR (Integration::Test01): hex cubature reports wrong accuracy.");
}
*outStream << "-> Prism testing\n\n";
{
CubatureTensorType prismCub( CubatureTriType(4), CubatureLineType(3) );
INTREPID2_TEST_FOR_EXCEPTION( prismCub.getDimension() != 3, std::logic_error,
">>> ERROR (Integration::Test01): prism cubature must have 3 dimension.");
ordinal_type accuracy[Parameters::MaxDimension];
prismCub.getAccuracy( accuracy );
INTREPID2_TEST_FOR_EXCEPTION( accuracy[0] != 4 || accuracy[1] != 3, std::logic_error,
">>> ERROR (Integration::Test01): prism cubature reports wrong accuracy.");
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
};
*outStream
<< "===============================================================================\n"
<< "| TEST 3: volume computations |\n"
<< "===============================================================================\n";
try {
DynRankView ConstructWithLabel(cubPoints, Parameters::MaxIntegrationPoints, Parameters::MaxDimension);
DynRankView ConstructWithLabel(cubWeights, Parameters::MaxIntegrationPoints);
*outStream << "-> Line testing\n\n";
{
for (ordinal_type deg=0;deg<=Parameters::MaxCubatureDegreeEdge;++deg) {
CubatureLineType cub(deg);
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 2.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Line volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Triangle testing\n\n";
{
for (auto deg=0;deg<=Parameters::MaxCubatureDegreeTri;++deg) {
CubatureTriType cub(deg);
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 0.5;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Triangle volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Quad testing\n\n";
{
for (ordinal_type y_deg=0;y_deg<=Parameters::MaxCubatureDegreeEdge;++y_deg)
for (ordinal_type x_deg=0;x_deg<=Parameters::MaxCubatureDegreeEdge;++x_deg) {
const auto x_line = CubatureLineType(x_deg);
const auto y_line = CubatureLineType(y_deg);
CubatureTensorType cub( x_line, y_line );
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 4.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Quadrilateral volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Tetrahedron testing\n\n";
{
for (auto deg=0;deg<=Parameters::MaxCubatureDegreeTet;++deg) {
CubatureTetType cub(deg);
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 1.0/6.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Tetrahedron volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Hexahedron testing\n\n";
{
// when hex is tested with max cubature degree edge, it exceeds max integration points 1001
for (ordinal_type z_deg=0;z_deg<Parameters::MaxCubatureDegreeEdge;++z_deg)
for (ordinal_type y_deg=0;y_deg<Parameters::MaxCubatureDegreeEdge;++y_deg)
for (ordinal_type x_deg=0;x_deg<Parameters::MaxCubatureDegreeEdge;++x_deg) {
const auto x_line = CubatureLineType(x_deg);
const auto y_line = CubatureLineType(y_deg);
const auto z_line = CubatureLineType(z_deg);
CubatureTensorType cub( x_line, y_line, z_line );
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 8.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Hexahedron volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Prism testing\n\n";
{
for (auto z_deg=0;z_deg<Parameters::MaxCubatureDegreeEdge;++z_deg)
for (auto xy_deg=0;xy_deg<Parameters::MaxCubatureDegreeTri;++xy_deg) {
const auto xy_tri = CubatureTriType(xy_deg);
const auto z_line = CubatureLineType(z_deg);
CubatureTensorType cub( xy_tri, z_line );
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 1.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Wedge volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Pyramid testing: over-integration by 2 (due to duffy transformation) \n\n";
{
for (auto deg=0;deg<=Parameters::MaxCubatureDegreePyr;++deg) {
const auto xy_line = CubatureLineType(deg);
const auto z_line = CubatureLineJacobiType(deg);
CubatureTensorPyrType cub( xy_line, xy_line, z_line );
cub.getCubature(cubPoints, cubWeights);
const auto npts = cub.getNumPoints();
const auto testVol = computeRefVolume(npts, cubWeights);
const auto refVol = 4.0/3.0;
if (std::abs(testVol - refVol) > tol) {
*outStream << std::setw(30) << "Pyramid volume --> " << std::setw(10) << std::scientific << testVol <<
std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - refVol) << "\n";
++errorFlag;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
}
}
}
*outStream << "-> Hypercube testing\n\n";
// later.... refVol = 32
// for (int deg=0; deg<=20; deg++) {
// Teuchos::RCP<CubatureLineType > lineCub = Teuchos::rcp(new CubatureLineType(deg));
// CubatureTensorType hypercubeCub(lineCub, 5);
// int numCubPoints = hypercubeCub.getNumPoints();
// FieldContainer<DeviceSpaceType> cubPoints( numCubPoints, hypercubeCub.getDimension() );
// FieldContainer<DeviceSpaceType> cubWeights( numCubPoints );
// hypercubeCub.getCubature(cubPoints, cubWeights);
// testVol = 0;
// for (int i=0; i<numCubPoints; i++)
// testVol += cubWeights(i);
// *outStream << std::setw(30) << "5-D Hypercube volume --> " << std::setw(10) << std::scientific << testVol <<
// std::setw(10) << "diff = " << std::setw(10) << std::scientific << std::abs(testVol - volumeList[8]) << "\n";
// if (std::abs(testVol - volumeList[8])/std::abs(testVol) > tol) {
// errorFlag = 1;
// *outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// }
// }
} catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1;
};
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);
Kokkos::finalize();
return errorFlag;
}
void
ArrayTools<ExecSpaceType>::
dotMultiplyDataField( /**/ Kokkos::DynRankView<outputFieldValueType,outputFieldProperties...> outputFields,
const Kokkos::DynRankView<inputDataValueType, inputDataProperties...> inputData,
const Kokkos::DynRankView<inputFieldValueType, inputFieldProperties...> inputFields ) {
#ifdef HAVE_INTREPID2_DEBUG
{
if (inputFields.rank() > inputData.rank()) {
INTREPID2_TEST_FOR_EXCEPTION( inputData.rank() < 2 || inputData.rank() > 4, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Input data container must have rank 2, 3 or 4.");
INTREPID2_TEST_FOR_EXCEPTION( inputFields.rank() != (inputData.rank()+1), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Input fields container must have rank one larger than the rank of the input data container.");
INTREPID2_TEST_FOR_EXCEPTION( outputFields.rank() != 3, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Output fields container must have rank 3.");
INTREPID2_TEST_FOR_EXCEPTION( inputFields.dimension(0) != inputData.dimension(0), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Zeroth dimensions (number of integration domains) of the fields and data input containers must agree!");
INTREPID2_TEST_FOR_EXCEPTION( inputData.dimension(1) != inputFields.dimension(2) &&
inputData.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Second dimension of the fields input container and first dimension of data input container (number of integration points) must agree or first data dimension must be 1!");
for (size_type i=2;i<inputData.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputData.dimension(i) != inputFields.dimension(i+1), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): inputData dimension (i) does not match to the dimension (i+1) of inputFields");
}
for (size_t i=0;i<outputFields.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputFields.dimension(i) != outputFields.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): inputFields dimension (i) does not match to the dimension (i+1) of outputFields");
}
} else {
INTREPID2_TEST_FOR_EXCEPTION( inputData.rank() < 2 || inputData.rank() > 4, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Input data container must have rank 2, 3 or 4.");
INTREPID2_TEST_FOR_EXCEPTION( inputFields.rank() != inputData.rank(), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): The rank of fields input container must equal the rank of data input container.");
INTREPID2_TEST_FOR_EXCEPTION( outputFields.rank() != 3, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Output fields container must have rank 3.");
INTREPID2_TEST_FOR_EXCEPTION( inputData.dimension(1) != inputFields.dimension(1) &&
inputData.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): First dimensions of the fields and data input containers (number of integration points) must agree or first data dimension must be 1!");
INTREPID2_TEST_FOR_EXCEPTION( inputFields.dimension(0) != outputFields.dimension(1), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Zeroth dimension of the fields input container and first dimension of the fields output container (number of fields) must agree!");
INTREPID2_TEST_FOR_EXCEPTION( inputFields.dimension(1) != outputFields.dimension(2), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): First dimension of the fields input container and second dimension of the fields output container (number of integration points) must agree!");
INTREPID2_TEST_FOR_EXCEPTION( outputFields.dimension(0) != inputData.dimension(0), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): Zeroth dimensions of the fields output and data input containers (number of integration domains) must agree!");
for (size_type i=2;i<inputData.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputData.dimension(i) != inputFields.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataField): inputData dimension (i) does not match to the dimension (i) of inputFields");
}
}
}
#endif
ArrayTools<ExecSpaceType>::Internal::dotMultiply( outputFields,
inputData,
inputFields,
true );
}
int FunctionSpaceTools_Test03(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 (FunctionSpaceTools) |\n"
<< "| |\n"
<< "| 1) Basic operator transformations and integration in HDIV: |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]) or |\n"
<< "| Denis Ridzal ([email protected]) or |\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 CellTools<DeviceSpaceType> ct;
typedef FunctionSpaceTools<DeviceSpaceType> fst;
typedef Kokkos::DynRankView<ValueType,DeviceSpaceType> DynRankView;
int errorFlag = 0;
*outStream
<< "\n"
<< "===============================================================================\n"
<< "| TEST 1: correctness of math operations |\n"
<< "===============================================================================\n";
outStream->precision(20);
try {
DefaultCubatureFactory cub_factory;
shards::CellTopology cell_topo = shards::getCellTopologyData< shards::Hexahedron<8> >();
const auto cub_degree = 20;
auto cub = cub_factory.create<DeviceSpaceType,ValueType,ValueType>(cell_topo, cub_degree);
const auto space_dim = cub->getDimension();
const auto num_cub_points = cub->getNumPoints();
Basis_HDIV_HEX_I1_FEM<DeviceSpaceType> basis;
const auto num_fields = basis.getCardinality();
/* Cell geometries and orientations. */
const auto num_cells = 4;
const auto num_nodes = 8;
const ValueType hexnodes[] = {
// hex 0 -- affine
-1.0, -1.0, -1.0,
1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
-1.0, -1.0, 1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0,
// hex 1 -- affine
-3.0, -3.0, 1.0,
6.0, 3.0, 1.0,
7.0, 8.0, 0.0,
-2.0, 2.0, 0.0,
-3.0, -3.0, 4.0,
6.0, 3.0, 4.0,
7.0, 8.0, 3.0,
-2.0, 2.0, 3.0,
// hex 2 -- affine
-3.0, -3.0, 0.0,
9.0, 3.0, 0.0,
15.0, 6.1, 0.0,
3.0, 0.1, 0.0,
9.0, 3.0, 0.1,
21.0, 9.0, 0.1,
27.0, 12.1, 0.1,
15.0, 6.1, 0.1,
// hex 3 -- nonaffine
-2.0, -2.0, 0.0,
2.0, -1.0, 0.0,
1.0, 6.0, 0.0,
-1.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 0.0, 1.0,
1.0, 1.0, 1.0,
0.0, 1.0, 1.0
};
const ValueType facesigns[] = {
1, 1, 1, 1, 1, 1,
1, -1, 1, -1, 1, -1,
-1, -1, 1, 1, -1, 1,
-1, -1, 1, 1, -1, -1
};
/* Computational arrays. */
DynRankView ConstructWithLabel( cub_points, num_cub_points, space_dim);
DynRankView ConstructWithLabel( cub_weights, num_cub_points);
DynRankView ConstructWithLabel( cell_nodes, num_cells, num_nodes, space_dim);
DynRankView ConstructWithLabel( field_signs, num_cells, num_fields);
DynRankView ConstructWithLabel( jacobian, num_cells, num_cub_points, space_dim, space_dim);
DynRankView ConstructWithLabel( jacobian_det, num_cells, num_cub_points);
DynRankView ConstructWithLabel( weighted_measure, num_cells, num_cub_points);
DynRankView ConstructWithLabel( div_of_basis_at_cub_points, num_fields, num_cub_points);
DynRankView ConstructWithLabel( transformed_div_of_basis_at_cub_points, num_cells, num_fields, num_cub_points);
DynRankView ConstructWithLabel( weighted_transformed_div_of_basis_at_cub_points, num_cells, num_fields, num_cub_points);
DynRankView ConstructWithLabel( stiffness_matrices, num_cells, num_fields, num_fields);
DynRankView ConstructWithLabel( value_of_basis_at_cub_points, num_fields, num_cub_points, space_dim);
DynRankView ConstructWithLabel( transformed_value_of_basis_at_cub_points, num_cells, num_fields, num_cub_points, space_dim);
DynRankView ConstructWithLabel( weighted_transformed_value_of_basis_at_cub_points, num_cells, num_fields, num_cub_points, space_dim);
DynRankView ConstructWithLabel( mass_matrices, num_cells, num_fields, num_fields);
/******************* START COMPUTATION ***********************/
// get cubature points and weights
cub->getCubature(cub_points, cub_weights);
const Kokkos::DynRankView<const ValueType,Kokkos::LayoutRight,Kokkos::HostSpace> cell_nodes_host (&hexnodes[0], num_cells, num_nodes, space_dim);
const Kokkos::DynRankView<const ValueType,Kokkos::LayoutRight,Kokkos::HostSpace> field_signs_host(&facesigns[0], num_cells, num_fields);
Kokkos::deep_copy( cell_nodes, cell_nodes_host );
Kokkos::deep_copy( field_signs, field_signs_host );
// compute geometric cell information
ct::setJacobian(jacobian, cub_points, cell_nodes, cell_topo);
ct::setJacobianDet(jacobian_det, jacobian);
// compute weighted measure
fst::computeCellMeasure(weighted_measure, jacobian_det, cub_weights);
// **Computing stiffness matrices:
basis.getValues(div_of_basis_at_cub_points, cub_points, OPERATOR_DIV);
// transform divergences of basis functions
fst::HDIVtransformDIV(transformed_div_of_basis_at_cub_points,
jacobian_det,
div_of_basis_at_cub_points);
// multiply with weighted measure
fst::multiplyMeasure(weighted_transformed_div_of_basis_at_cub_points,
weighted_measure,
transformed_div_of_basis_at_cub_points);
// we can apply the field signs to the basis function arrays, or after the fact, see below
fst::applyFieldSigns(transformed_div_of_basis_at_cub_points, field_signs);
fst::applyFieldSigns(weighted_transformed_div_of_basis_at_cub_points, field_signs);
// compute stiffness matrices
fst::integrate(stiffness_matrices,
transformed_div_of_basis_at_cub_points,
weighted_transformed_div_of_basis_at_cub_points);
// **Computing mass matrices:
basis.getValues(value_of_basis_at_cub_points, cub_points, OPERATOR_VALUE);
// transform values of basis functions
fst::HDIVtransformVALUE(transformed_value_of_basis_at_cub_points,
jacobian,
jacobian_det,
value_of_basis_at_cub_points);
// multiply with weighted measure
fst::multiplyMeasure(weighted_transformed_value_of_basis_at_cub_points,
weighted_measure,
transformed_value_of_basis_at_cub_points);
// compute mass matrices
fst::integrate(mass_matrices,
transformed_value_of_basis_at_cub_points,
weighted_transformed_value_of_basis_at_cub_points);
// apply field signs
fst::applyLeftFieldSigns(mass_matrices, field_signs);
fst::applyRightFieldSigns(mass_matrices, field_signs);
/******************* STOP COMPUTATION ***********************/
/******************* START COMPARISON ***********************/
std::string basedir = "../testdata";
for (auto cid=0;cid<num_cells-1;++cid) {
std::stringstream namestream;
std::string filename;
namestream << basedir << "/mass_HDIV_HEX_I1_FEM" << "_" << "0" << cid+1 << ".dat";
namestream >> filename;
*outStream << "\nCell ID : " << cid << " mass matrix comparing with " << filename << "\n\n";
std::ifstream massfile(&filename[0]);
if (massfile.is_open()) {
const auto mass_matrix_cell = Kokkos::subdynrankview(mass_matrices, cid, Kokkos::ALL(), Kokkos::ALL());
errorFlag += compareToAnalytic(massfile,
mass_matrix_cell,
1e-10,
verbose);
massfile.close();
} else {
errorFlag = -1;
INTREPID2_TEST_FOR_EXCEPTION( true, std::runtime_error,
"Failed to open a file" );
}
namestream.clear();
namestream << basedir << "/stiff_HDIV_HEX_I1_FEM" << "_" << "0" << cid+1 << ".dat";
namestream >> filename;
*outStream << "\nCell ID : " << cid << " stiffness matrix comparing with " << filename << "\n\n";
std::ifstream stifffile(&filename[0]);
if (stifffile.is_open()) {
const auto stiffness_matrix_cell = Kokkos::subdynrankview(stiffness_matrices, cid, Kokkos::ALL(), Kokkos::ALL());
errorFlag += compareToAnalytic(stifffile,
stiffness_matrix_cell,
1e-10,
verbose);
stifffile.close();
} else {
errorFlag = -1;
INTREPID2_TEST_FOR_EXCEPTION( true, std::runtime_error,
"Failed to open a file" );
}
}
for (auto cid=3;cid<num_cells;++cid) {
std::stringstream namestream;
std::string filename;
namestream << basedir << "/mass_fp_HDIV_HEX_I1_FEM" << "_" << "0" << cid+1 << ".dat";
namestream >> filename;
*outStream << "\nCell ID : " << cid << " mass matrix comparing with " << filename << "\n\n";
std::ifstream massfile(&filename[0]);
if (massfile.is_open()) {
const auto mass_matrix_cell = Kokkos::subdynrankview(mass_matrices, cid, Kokkos::ALL(), Kokkos::ALL());
errorFlag += compareToAnalytic(massfile,
mass_matrix_cell,
1e-4,
verbose,
INTREPID2_UTILS_SCALAR);
massfile.close();
} else {
errorFlag = -1;
INTREPID2_TEST_FOR_EXCEPTION( true, std::runtime_error,
"Failed to open a file" );
}
namestream.clear();
namestream << basedir << "/stiff_fp_HDIV_HEX_I1_FEM" << "_" << "0" << cid+1 << ".dat";
namestream >> filename;
*outStream << "\nCell ID : " << cid << " stiffness matrix comparing with " << filename << "\n\n";
std::ifstream stifffile(&filename[0]);
if (stifffile.is_open()) {
const auto stiffness_matrix_cell = Kokkos::subdynrankview(stiffness_matrices, cid, Kokkos::ALL(), Kokkos::ALL());
errorFlag += compareToAnalytic(stifffile,
stiffness_matrix_cell,
1e-4,
verbose,
INTREPID2_UTILS_SCALAR);
stifffile.close();
} else {
errorFlag = -1;
INTREPID2_TEST_FOR_EXCEPTION( true, std::runtime_error,
"Failed to open a file" );
}
}
/******************* STOP COMPARISON ***********************/
*outStream << "\n";
} catch (std::logic_error 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;
}
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;
}
void
CellTools<SpT>::
setSubcellParametrization( subcellParamViewType &subcellParam,
const ordinal_type subcellDim,
const shards::CellTopology parentCell ) {
#ifdef HAVE_INTREPID2_DEBUG
INTREPID2_TEST_FOR_EXCEPTION( !hasReferenceCell(parentCell), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::setSubcellParametrization): the specified cell topology does not have a reference cell.");
#endif
// subcellParametrization is rank-3 FieldContainer with dimensions (SC, PCD, COEF) where:
// - SC is the subcell count of subcells with the specified dimension in the parent cell
// - PCD is Parent Cell Dimension, which gives the number of coordinate functions in the map
// PCD = 2 for standard 2D cells and non-standard 2D cells: shell line and beam
// PCD = 3 for standard 3D cells and non-standard 3D cells: shell Tri and Quad
// - COEF is number of coefficients needed to specify a coordinate function:
// COEFF = 2 for edge parametrizations
// COEFF = 3 for both Quad and Tri face parametrizations. Because all Quad reference faces
// are affine, the coefficient of the bilinear term u*v is zero and is not stored, i.e.,
// 3 coefficients are sufficient to store Quad face parameterization maps.
//
// Edge parametrization maps [-1,1] to edge defined by (v0, v1)
// Face parametrization maps [-1,1]^2 to quadrilateral face (v0, v1, v2, v3), or
// standard 2-simplex {(0,0),(1,0),(0,1)} to traingle face (v0, v1, v2).
// This defines orientation-preserving parametrizations with respect to reference edge and
// face orientations induced by their vertex order.
// get subcellParametrization dimensions: (sc, pcd, coeff)
const auto sc = parentCell.getSubcellCount(subcellDim);
const auto pcd = parentCell.getDimension();
const auto coeff = (subcellDim == 1) ? 2 : 3;
INTREPID2_TEST_FOR_EXCEPTION( subcellDim < 1 || subcellDim > static_cast<ordinal_type>(pcd-1), std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::setSubcellParametrization): Parametrizations defined in a range between 1 and (dim-1)");
// create a view
subcellParam = subcellParamViewType("CellTools::setSubcellParametrization",
sc, pcd, coeff);
referenceNodeDataViewType
v0("CellTools::setSubcellParametrization::v0", Parameters::MaxDimension),
v1("CellTools::setSubcellParametrization::v1", Parameters::MaxDimension),
v2("CellTools::setSubcellParametrization::v1", Parameters::MaxDimension),
v3("CellTools::setSubcellParametrization::v1", Parameters::MaxDimension);
if (subcellDim == 1) {
// Edge parametrizations of 2D and 3D cells (shell lines and beams are 2D cells with edges)
for (size_type subcellOrd=0;subcellOrd<sc;++subcellOrd) {
// vertexK[0] = x_k; vertexK[1] = y_k; vertexK[2] = z_k; z_k = 0 for 2D cells
// Note that ShellLine and Beam are 2D cells!
const auto v0ord = parentCell.getNodeMap(subcellDim, subcellOrd, 0);
const auto v1ord = parentCell.getNodeMap(subcellDim, subcellOrd, 1);
getReferenceVertex(v0, parentCell, v0ord);
getReferenceVertex(v1, parentCell, v1ord);
// x(t) = (x0 + x1)/2 + t*(x1 - x0)/2
subcellParam(subcellOrd, 0, 0) = (v0[0] + v1[0])/2.0;
subcellParam(subcellOrd, 0, 1) = (v1[0] - v0[0])/2.0;
// y(t) = (y0 + y1)/2 + t*(y1 - y0)/2
subcellParam(subcellOrd, 1, 0) = (v0[1] + v1[1])/2.0;
subcellParam(subcellOrd, 1, 1) = (v1[1] - v0[1])/2.0;
if( pcd == 3 ) {
// z(t) = (z0 + z1)/2 + t*(z1 - z0)/2
subcellParam(subcellOrd, 2, 0) = (v0[2] + v1[2])/2.0;
subcellParam(subcellOrd, 2, 1) = (v1[2] - v0[2])/2.0;
}
}
}
else if (subcellDim == 2) {
// Face parametrizations of 3D cells: (shell Tri and Quad are 3D cells with faces)
// A 3D cell can have both Tri and Quad faces, but because they are affine images of the
// parametrization domain, 3 coefficients are enough to store them in both cases.
for (size_type subcellOrd=0;subcellOrd<sc;++subcellOrd) {
switch (parentCell.getKey(subcellDim,subcellOrd)) {
case shards::Triangle<3>::key:
case shards::Triangle<4>::key:
case shards::Triangle<6>::key: {
const auto v0ord = parentCell.getNodeMap(subcellDim, subcellOrd, 0);
const auto v1ord = parentCell.getNodeMap(subcellDim, subcellOrd, 1);
const auto v2ord = parentCell.getNodeMap(subcellDim, subcellOrd, 2);
getReferenceVertex(v0, parentCell, v0ord);
getReferenceVertex(v1, parentCell, v1ord);
getReferenceVertex(v2, parentCell, v2ord);
// x(u,v) = x0 + (x1 - x0)*u + (x2 - x0)*v
subcellParam(subcellOrd, 0, 0) = v0[0];
subcellParam(subcellOrd, 0, 1) = v1[0] - v0[0];
subcellParam(subcellOrd, 0, 2) = v2[0] - v0[0];
// y(u,v) = y0 + (y1 - y0)*u + (y2 - y0)*v
subcellParam(subcellOrd, 1, 0) = v0[1];
subcellParam(subcellOrd, 1, 1) = v1[1] - v0[1];
subcellParam(subcellOrd, 1, 2) = v2[1] - v0[1];
// z(u,v) = z0 + (z1 - z0)*u + (z2 - z0)*v
subcellParam(subcellOrd, 2, 0) = v0[2];
subcellParam(subcellOrd, 2, 1) = v1[2] - v0[2];
subcellParam(subcellOrd, 2, 2) = v2[2] - v0[2];
break;
}
case shards::Quadrilateral<4>::key:
case shards::Quadrilateral<8>::key:
case shards::Quadrilateral<9>::key: {
const auto v0ord = parentCell.getNodeMap(subcellDim, subcellOrd, 0);
const auto v1ord = parentCell.getNodeMap(subcellDim, subcellOrd, 1);
const auto v2ord = parentCell.getNodeMap(subcellDim, subcellOrd, 2);
const auto v3ord = parentCell.getNodeMap(subcellDim, subcellOrd, 3);
getReferenceVertex(v0, parentCell, v0ord);
getReferenceVertex(v1, parentCell, v1ord);
getReferenceVertex(v2, parentCell, v2ord);
getReferenceVertex(v3, parentCell, v3ord);
// x(u,v) = (x0+x1+x2+x3)/4+u*(-x0+x1+x2-x3)/4+v*(-x0-x1+x2+x3)/4+uv*(0=x0-x1+x2-x3)/4
subcellParam(subcellOrd, 0, 0) = ( v0[0] + v1[0] + v2[0] + v3[0])/4.0;
subcellParam(subcellOrd, 0, 1) = (-v0[0] + v1[0] + v2[0] - v3[0])/4.0;
subcellParam(subcellOrd, 0, 2) = (-v0[0] - v1[0] + v2[0] + v3[0])/4.0;
// y(u,v) = (y0+y1+y2+y3)/4+u*(-y0+y1+y2-y3)/4+v*(-y0-y1+y2+y3)/4+uv*(0=y0-y1+y2-y3)/4
subcellParam(subcellOrd, 1, 0) = ( v0[1] + v1[1] + v2[1] + v3[1])/4.0;
subcellParam(subcellOrd, 1, 1) = (-v0[1] + v1[1] + v2[1] - v3[1])/4.0;
subcellParam(subcellOrd, 1, 2) = (-v0[1] - v1[1] + v2[1] + v3[1])/4.0;
// z(u,v) = (z0+z1+z2+z3)/4+u*(-z0+z1+z2-z3)/4+v*(-z0-z1+z2+z3)/4+uv*(0=z0-z1+z2-z3)/4
subcellParam(subcellOrd, 2, 0) = ( v0[2] + v1[2] + v2[2] + v3[2])/4.0;
subcellParam(subcellOrd, 2, 1) = (-v0[2] + v1[2] + v2[2] - v3[2])/4.0;
subcellParam(subcellOrd, 2, 2) = (-v0[2] - v1[2] + v2[2] + v3[2])/4.0;
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( true, std::invalid_argument,
">>> ERROR (Intrepid2::CellTools::setSubcellParametrization): parametrization not defined for the specified face topology.");
}
}
}
}
}
void
ArrayTools<ExecSpaceType>::
dotMultiplyDataData( /**/ Kokkos::DynRankView<outputDataValueType, outputDataProperties...> outputData,
const Kokkos::DynRankView<inputDataLeftValueType, inputDataLeftProperties...> inputDataLeft,
const Kokkos::DynRankView<inputDataRightValueType,inputDataRightProperties...> inputDataRight ) {
#ifdef HAVE_INTREPID2_DEBUG
{
if (inputDataRight.rank() >= inputDataLeft.rank()) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.rank() < 2 || inputDataLeft.rank() > 4, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Left data input container must have rank 2, 3 or 4.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() != inputDataLeft.rank(), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): The rank of the right data input container must equal the rank of the left data input container.");
INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != 2, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Data output container must have rank 2.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(1) != inputDataRight.dimension(1) &&
inputDataLeft.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): First dimensions of the left and right data input containers (number of integration points) must agree or first left data dimension must be 1!");
for (size_type i=0;i<inputDataLeft.rank();++i) {
if (i != 1) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(i) != inputDataRight.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): inputDataLeft dimension (i) does not match to the dimension (i) of inputDataRight");
}
}
for (size_type i=0;i<outputData.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.dimension(i) != outputData.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): inputDataRight dimension (i) does not match to the dimension (i) of outputData");
}
} else {
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.rank() < 2 || inputDataLeft.rank() > 4, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Left data input container must have rank 2, 3 or 4.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.rank() != (inputDataLeft.rank()-1), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Right data input container must have rank one less than the rank of left data input container.");
INTREPID2_TEST_FOR_EXCEPTION( outputData.rank() != 2, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Data output container must have rank 2.");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(1) != inputDataRight.dimension(0) &&
inputDataLeft.dimension(1) != 1, std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Zeroth dimension of the right data input container and first dimension of left data input container (number of integration points) must agree or first left data dimension must be 1!");
INTREPID2_TEST_FOR_EXCEPTION( inputDataRight.dimension(0) != outputData.dimension(1), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Zeroth dimension of the right data input container and first dimension of output data container (number of integration points) must agree!");
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(0) != outputData.dimension(0), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): Zeroth dimensions of the left data input and data output containers (number of integration domains) must agree!");
for (size_type i=1;i<inputDataRight.rank();++i) {
INTREPID2_TEST_FOR_EXCEPTION( inputDataLeft.dimension(i+1) != inputDataRight.dimension(i), std::invalid_argument,
">>> ERROR (ArrayTools::dotMultiplyDataData): inputDataLeft dimension (i+1) does not match to the dimension (i) of inputDataRight");
}
}
}
#endif
ArrayTools<ExecSpaceType>::Internal::dotMultiply( outputData,
inputDataLeft,
inputDataRight,
false );
}
int Integration_Test10(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 (CubaturePolylib) |\n"
<< "| |\n"
<< "| 1) Computing integrals of monomials on reference cells in 1D |\n"
<< "| |\n"
<< "| Questions? Contact Pavel Bochev ([email protected]) or |\n"
<< "| Denis Ridzal ([email protected]) or |\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"
<< "| TEST 1: integrals of monomials in 1D |\n"
<< "===============================================================================\n";
typedef Kokkos::DynRankView<ValueType,DeviceSpaceType> DynRankView;
#define ConstructWithLabel(obj, ...) obj(#obj, __VA_ARGS__)
typedef ValueType pointValueType;
typedef ValueType weightValueType;
typedef CubaturePolylib<DeviceSpaceType,pointValueType,weightValueType> CubatureLineType;
const auto tol = 10.0 * tolerence();
int errorFlag = 0;
// open file with analytic values
std::string basedir = "../data";
std::stringstream namestream;
std::string filename;
namestream << basedir << "/EDGE_integrals" << ".dat";
namestream >> filename;
*outStream << "filename = " << filename << std::endl;
std::ifstream filecompare(filename);
*outStream << "\n-> Integrals of monomials on a reference line (edge):\n";
// compute and compare integrals
try {
const auto maxDeg = Parameters::MaxCubatureDegreeEdge;
const auto polySize = maxDeg + 1;
// test inegral values
DynRankView ConstructWithLabel(testInt, maxDeg+1, polySize);
// analytic integral values
DynRankView ConstructWithLabel(analyticInt, maxDeg+1, polySize);
// get analytic values
if (filecompare.is_open()) {
getAnalytic(analyticInt, filecompare);
filecompare.close();
} else {
INTREPID2_TEST_FOR_EXCEPTION( true, std::runtime_error,
">>> ERROR (Integration::Test02): Cannot open analytic solution file" );
}
// storage for cubatrue points and weights
DynRankView ConstructWithLabel(cubPoints,
Parameters::MaxIntegrationPoints,
Parameters::MaxDimension);
DynRankView ConstructWithLabel(cubWeights,
Parameters::MaxIntegrationPoints);
// compute integrals
EPolyType polyType[4] = { POLYTYPE_GAUSS,
POLYTYPE_GAUSS_RADAU_LEFT,
POLYTYPE_GAUSS_RADAU_RIGHT,
POLYTYPE_GAUSS_LOBATTO };
for (size_type pid=0;pid<4;++pid) {
const auto ptype = polyType[pid];
*outStream << "\n -> Testing poly type " << EPolyTypeToString(ptype) << "\n";
for (size_type cubDeg=0;cubDeg<=maxDeg;++cubDeg) {
CubatureLineType lineCub(cubDeg, ptype);
for (auto polyDeg=0;polyDeg<=cubDeg;++polyDeg)
testInt(cubDeg, polyDeg) = computeIntegralOfMonomial<ValueType>(lineCub,
cubPoints,
cubWeights,
polyDeg);
}
// perform comparison
for (size_type cubDeg=0;cubDeg<=maxDeg;++cubDeg) {
for (auto polyDeg=0;polyDeg<=cubDeg;++polyDeg) {
const auto abstol = ( analyticInt(polyDeg,0) == 0 ? tol : std::fabs(tol*analyticInt(polyDeg,0)) );
const auto absdiff = std::fabs(analyticInt(polyDeg,0) - testInt(cubDeg,polyDeg));
*outStream << "Cubature order " << std::setw(2) << std::left << cubDeg << " integrating "
<< "x^" << std::setw(2) << std::left << polyDeg << ":" << " "
<< std::scientific << std::setprecision(16) << testInt(cubDeg,polyDeg) << " " << analyticInt(polyDeg,0) << " "
<< std::setprecision(4) << absdiff << " " << "<?" << " " << abstol << "\n";
if (absdiff > abstol) {
errorFlag++;
*outStream << std::right << std::setw(104) << "^^^^---FAILURE!\n";
}
}
*outStream << "\n";
}
}
} catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1;
}
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;
}
virtual
void
getDofCoeffs( scalarViewType /* dofCoeffs */ ) const {
INTREPID2_TEST_FOR_EXCEPTION( true, std::logic_error,
">>> ERROR (Basis::getDofCoeffs): this method is not supported or should be over-riden accordingly by derived classes.");
}
