void
Basis_HGRAD_TRI_Cn_FEM_ORTH::
getValues( /**/ Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
const ordinal_type order,
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;
// loopSize corresponds to the # of points
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);
switch (operatorType) {
case OPERATOR_VALUE: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_VALUE,numPtsPerEval> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints,
order) );
break;
}
case OPERATOR_GRAD:
case OPERATOR_D1: {
typedef Functor<outputValueViewType,inputPointViewType,OPERATOR_GRAD,numPtsPerEval> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints,
order) );
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_Dn,numPtsPerEval> FunctorType;
Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints,
order, getOperatorOrder(operatorType)) );
break;
}
case OPERATOR_DIV:
case OPERATOR_CURL: {
INTREPID2_TEST_FOR_EXCEPTION( operatorType == OPERATOR_DIV ||
operatorType == OPERATOR_CURL, std::invalid_argument,
">>> ERROR (Basis_HGRAD_TRI_Cn_FEM_ORTH): invalid operator type (div and curl).");
break;
}
default: {
INTREPID2_TEST_FOR_EXCEPTION( !Intrepid2::isValidOperator(operatorType), std::invalid_argument,
">>> ERROR (Basis_HGRAD_TRI_Cn_FEM_ORTH): invalid operator type");
}
}
}
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
}
}
}
KOKKOS_INLINE_FUNCTION
void
Basis_HGRAD_TRI_Cn_FEM_ORTH::Serial<opType>::
getValues( /**/ outputViewType output,
const inputViewType input,
const ordinal_type order,
const ordinal_type operatorDn ) {
ordinal_type opDn = operatorDn;
switch (opType) {
case OPERATOR_VALUE: {
OrthPolynomial<0>( output, order, input );
break;
}
case OPERATOR_GRAD:
case OPERATOR_D1: {
OrthPolynomial<1>( output, order, input );
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:
opDn = getOperatorOrder(opType);
case OPERATOR_Dn: {
OrthPolynomial( output, order, input, opDn );
break;
}
default: {
INTREPID2_TEST_FOR_ABORT( true,
">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM_ORTH::Serial::getValues) operator is not supported");
}
}
}
KOKKOS_INLINE_FUNCTION
void
Basis_HGRAD_LINE_Cn_FEM::Serial<opType>::
getValues( outputViewType output,
const inputViewType input,
workViewType work,
const vinvViewType vinv,
const ordinal_type operatorDn ) {
ordinal_type opDn = operatorDn;
const ordinal_type card = vinv.dimension(0);
const ordinal_type npts = input.dimension(0);
const ordinal_type order = card - 1;
const double alpha = 0.0, beta = 0.0;
typedef typename Kokkos::DynRankView<typename workViewType::value_type, typename workViewType::memory_space> viewType;
auto vcprop = Kokkos::common_view_alloc_prop(work);
switch (opType) {
case OPERATOR_VALUE: {
viewType phis(Kokkos::view_wrap(work.data(), vcprop), card, npts);
Impl::Basis_HGRAD_LINE_Cn_FEM_JACOBI::
Serial<opType>::getValues(phis, input, order, alpha, beta);
for (ordinal_type i=0;i<card;++i)
for (ordinal_type j=0;j<npts;++j) {
output(i,j) = 0.0;
for (ordinal_type k=0;k<card;++k)
output(i,j) += vinv(k,i)*phis(k,j);
}
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:
opDn = getOperatorOrder(opType);
case OPERATOR_Dn: {
// dkcard is always 1 for 1D element
const ordinal_type dkcard = 1;
viewType phis(Kokkos::view_wrap(work.data(), vcprop), card, npts, dkcard);
Impl::Basis_HGRAD_LINE_Cn_FEM_JACOBI::
Serial<opType>::getValues(phis, input, order, alpha, beta, opDn);
for (ordinal_type i=0;i<card;++i)
for (ordinal_type j=0;j<npts;++j)
for (ordinal_type k=0;k<dkcard;++k) {
output(i,j,k) = 0.0;
for (ordinal_type l=0;l<card;++l)
output(i,j,k) += vinv(l,i)*phis(l,j,k);
}
break;
}
default: {
INTREPID2_TEST_FOR_ABORT( true,
">>> ERROR: (Intrepid2::Basis_HGRAD_LINE_Cn_FEM::Serial::getValues) operator is not supported." );
}
}
}
void Basis_HGRAD_LINE_Cn_FEM_JACOBI<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
const ArrayScalar & inputPoints,
const EOperator operatorType) const {
// Verify arguments
#ifdef HAVE_INTREPID2_DEBUG
Intrepid2::getValues_HGRAD_Args<Scalar, ArrayScalar>(outputValues,
inputPoints,
operatorType,
this -> getBaseCellTopology(),
this -> getCardinality() );
#endif
// Number of evaluation points = dimension 0 of inputPoints
int numPoints = inputPoints.dimension(0);
Teuchos::Array<Scalar> tmpPoints(numPoints);
Teuchos::Array<Scalar> jacobiPolyAtPoints(numPoints);
// Copy inputPoints into tmpPoints, to prepare for call to jacobfd
for (int i=0; i<numPoints; i++) {
tmpPoints[i] = inputPoints(i, 0);
}
try {
switch (operatorType) {
case OPERATOR_VALUE: {
for (int ord = 0; ord < this -> basisCardinality_; ord++) {
IntrepidPolylib::jacobfd(numPoints, &tmpPoints[0], &jacobiPolyAtPoints[0], (Scalar*)0, ord, jacobiAlpha_, jacobiBeta_);
for (int pt = 0; pt < numPoints; pt++) {
// outputValues is a rank-2 array with dimensions (basisCardinality_, numPoints)
outputValues(ord, pt) = jacobiPolyAtPoints[pt];
}
}
}
break;
case OPERATOR_GRAD:
case OPERATOR_D1: {
for (int ord = 0; ord < this -> basisCardinality_; ord++) {
IntrepidPolylib::jacobd(numPoints, &tmpPoints[0], &jacobiPolyAtPoints[0], ord, jacobiAlpha_, jacobiBeta_);
for (int pt = 0; pt < numPoints; pt++) {
// outputValues is a rank-2 array with dimensions (basisCardinality_, numPoints)
outputValues(ord, pt, 0) = jacobiPolyAtPoints[pt];
}
}
}
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: {
int d_order = getOperatorOrder( operatorType );
// fill in derivatives of polynomials of degree 0 through d_order - 1 with 0
// e.g. D2 annhialates linears.
int stop_order;
if (d_order > this->getDegree()) {
stop_order = this->getDegree();
}
else {
stop_order = d_order;
}
for (int p_order=0;p_order<stop_order;p_order++) {
for (int pt=0;pt<numPoints;pt++) {
outputValues(p_order,pt,0) = 0.0;
}
}
// fill in rest of derivatives with the differentiation rule for Jacobi polynomials
for (int p_order=d_order;p_order<=this->getDegree();p_order++) {
// calculate the scaling factor with a little loop.
Scalar scalefactor = 1.0;
for (int d=1;d<=d_order;d++) {
scalefactor *= 0.5 * ( p_order + jacobiAlpha_ + jacobiBeta_ + d );
}
// put in the right call to IntrepidPolyLib
IntrepidPolylib::jacobfd(numPoints, &tmpPoints[0],
&jacobiPolyAtPoints[0],
(Scalar*)0, p_order-d_order,
jacobiAlpha_ + d_order,
jacobiBeta_ + d_order);
for (int pt = 0; pt < numPoints; pt++) {
// outputValues is a rank-3 array with dimensions (basisCardinality_, numPoints)
outputValues(p_order, pt,0) = scalefactor *jacobiPolyAtPoints[pt];
}
}
}
break;
case OPERATOR_DIV:
case OPERATOR_CURL:
TEUCHOS_TEST_FOR_EXCEPTION( !( Intrepid2::isValidOperator(operatorType) ), std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Cn_FEM_JACOBI): Invalid operator type.");
break;
default:
TEUCHOS_TEST_FOR_EXCEPTION( !( Intrepid2::isValidOperator(operatorType) ), std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Cn_FEM_JACOBI): Invalid operator type.");
break;
}
}
catch (std::invalid_argument &exception){
TEUCHOS_TEST_FOR_EXCEPTION( true , std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Cn_FEM_JACOBI): Operator failed");
}
}