Intrepid2
Intrepid2_HGRAD_TRI_Cn_FEMDef.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// Intrepid2 Package
4//
5// Copyright 2007 NTESS and the Intrepid2 contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
16#ifndef __INTREPID2_HGRAD_TRI_CN_FEM_DEF_HPP__
17#define __INTREPID2_HGRAD_TRI_CN_FEM_DEF_HPP__
18
19#include "Intrepid2_HGRAD_TRI_Cn_FEM_ORTH.hpp"
20
21namespace Intrepid2 {
22
23// -------------------------------------------------------------------------------------
24namespace Impl {
25
26template<EOperator OpType>
27template<typename OutputViewType,
28typename InputViewType,
29typename WorkViewType,
30typename VinvViewType>
31KOKKOS_INLINE_FUNCTION
32void
33Basis_HGRAD_TRI_Cn_FEM::Serial<OpType>::
34getValues( OutputViewType output,
35 const InputViewType input,
36 WorkViewType work,
37 const VinvViewType vinv,
38 const ordinal_type order ) {
39
40 constexpr ordinal_type spaceDim = 2;
41 const ordinal_type
42 card = vinv.extent(0),
43 npts = input.extent(0);
44
45 typedef typename Kokkos::DynRankView<typename InputViewType::value_type, typename WorkViewType::memory_space> ViewType;
46 auto vcprop = Kokkos::common_view_alloc_prop(input);
47 auto ptr = work.data();
48
49 switch (OpType) {
50 case OPERATOR_VALUE: {
51 const ViewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts);
52 ViewType dummyView;
53
54 Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
55 Serial<OpType>::getValues(phis, input, dummyView, order);
56
57 for (ordinal_type i=0;i<card;++i)
58 for (ordinal_type j=0;j<npts;++j) {
59 output.access(i,j) = 0.0;
60 for (ordinal_type k=0;k<card;++k)
61 output.access(i,j) += vinv(k,i)*phis.access(k,j);
62 }
63 break;
64 }
65 case OPERATOR_GRAD:
66 case OPERATOR_D1: {
67 const ViewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim);
68 ptr += card*npts*spaceDim*get_dimension_scalar(input);
69 const ViewType workView(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim+1);
70 Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
71 Serial<OpType>::getValues(phis, input, workView, order);
72
73 for (ordinal_type i=0;i<card;++i)
74 for (ordinal_type j=0;j<npts;++j)
75 for (ordinal_type k=0;k<spaceDim;++k) {
76 output.access(i,j,k) = 0.0;
77 for (ordinal_type l=0;l<card;++l)
78 output.access(i,j,k) += vinv(l,i)*phis.access(l,j,k);
79 }
80 break;
81 }
82 case OPERATOR_D2:
83 case OPERATOR_D3:
84 case OPERATOR_D4:
85 case OPERATOR_D5:
86 case OPERATOR_D6:
87 case OPERATOR_D7:
88 case OPERATOR_D8:
89 case OPERATOR_D9:
90 case OPERATOR_D10: {
91 const ordinal_type dkcard = getDkCardinality<OpType,spaceDim>(); //(orDn + 1);
92 const ViewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, dkcard);
93 ViewType dummyView;
94
95 Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
96 Serial<OpType>::getValues(phis, input, dummyView, order);
97
98 for (ordinal_type i=0;i<card;++i)
99 for (ordinal_type j=0;j<npts;++j)
100 for (ordinal_type k=0;k<dkcard;++k) {
101 output.access(i,j,k) = 0.0;
102 for (ordinal_type l=0;l<card;++l)
103 output.access(i,j,k) += vinv(l,i)*phis.access(l,j,k);
104 }
105 break;
106 }
107 case OPERATOR_CURL: { // only works in 2d. first component is -d/dy, second is d/dx
108 const ViewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim);
109 ptr += card*npts*spaceDim*get_dimension_scalar(input);
110 const ViewType workView(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim+1);
111
112
113 Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
114 Serial<OPERATOR_D1>::getValues(phis, input, workView, order);
115
116 for (ordinal_type i=0;i<card;++i)
117 for (ordinal_type j=0;j<npts;++j) {
118 output.access(i,j,0) = 0.0;
119 for (ordinal_type l=0;l<card;++l)
120 output.access(i,j,0) += vinv(l,i)*phis.access(l,j,1);
121 output.access(i,j,1) = 0.0;
122 for (ordinal_type l=0;l<card;++l)
123 output.access(i,j,1) -= vinv(l,i)*phis.access(l,j,0);
124 }
125 break;
126 }
127 default: {
128 INTREPID2_TEST_FOR_ABORT( true,
129 ">>> ERROR (Basis_HGRAD_TRI_Cn_FEM): Operator type not implemented");
130 }
131 }
132}
133
134template<typename DT, ordinal_type numPtsPerEval,
135typename outputValueValueType, class ...outputValueProperties,
136typename inputPointValueType, class ...inputPointProperties,
137typename vinvValueType, class ...vinvProperties>
138void
139Basis_HGRAD_TRI_Cn_FEM::
140getValues(
141 const typename DT::execution_space& space,
142 Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
143 const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
144 const Kokkos::DynRankView<vinvValueType, vinvProperties...> vinv,
145 const ordinal_type order,
146 const EOperator operatorType) {
147 typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
148 typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
149 typedef Kokkos::DynRankView<vinvValueType, vinvProperties...> vinvViewType;
150 typedef typename ExecSpace<typename inputPointViewType::execution_space,typename DT::execution_space>::ExecSpaceType ExecSpaceType;
151
152 // loopSize corresponds to cardinality
153 const auto loopSizeTmp1 = (inputPoints.extent(0)/numPtsPerEval);
154 const auto loopSizeTmp2 = (inputPoints.extent(0)%numPtsPerEval != 0);
155 const auto loopSize = loopSizeTmp1 + loopSizeTmp2;
156 Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(space, 0, loopSize);
157
158 typedef typename inputPointViewType::value_type inputPointType;
159
160 const ordinal_type cardinality = outputValues.extent(0);
161 const ordinal_type spaceDim = 2;
162
163 auto vcprop = Kokkos::common_view_alloc_prop(inputPoints);
164 typedef typename Kokkos::DynRankView< inputPointType, typename inputPointViewType::memory_space> workViewType;
165
166 switch (operatorType) {
167 case OPERATOR_VALUE: {
168 workViewType work(Kokkos::view_alloc(space, "Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality, inputPoints.extent(0));
169 typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
170 OPERATOR_VALUE,numPtsPerEval> FunctorType;
171 Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work, order) );
172 break;
173 }
174 case OPERATOR_GRAD:
175 case OPERATOR_D1: {
176 workViewType work(Kokkos::view_alloc(space, "Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*(2*spaceDim+1), inputPoints.extent(0));
177 typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
178 OPERATOR_D1,numPtsPerEval> FunctorType;
179 Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work, order) );
180 break;
181 }
182 case OPERATOR_CURL: {
183 workViewType work(Kokkos::view_alloc(space, "Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*(2*spaceDim+1), inputPoints.extent(0));
184 typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
185 OPERATOR_CURL,numPtsPerEval> FunctorType;
186 Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work, order) );
187 break;
188 }
189 case OPERATOR_D2: {
190 typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
191 OPERATOR_D2,numPtsPerEval> FunctorType;
192 workViewType work(Kokkos::view_alloc(space, "Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*outputValues.extent(2), inputPoints.extent(0));
193 Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work, order) );
194 break;
195 }
196 default: {
197 INTREPID2_TEST_FOR_EXCEPTION( true , std::invalid_argument,
198 ">>> ERROR (Basis_HGRAD_TRI_Cn_FEM): Operator type not implemented" );
199 }
200 }
201}
202}
203
204// -------------------------------------------------------------------------------------
205template<typename DT, typename OT, typename PT>
206Basis_HGRAD_TRI_Cn_FEM<DT,OT,PT>::
207Basis_HGRAD_TRI_Cn_FEM( const ordinal_type order,
208 const EPointType pointType ) {
209 constexpr ordinal_type spaceDim = 2;
210
211 this->basisCardinality_ = Intrepid2::getPnCardinality<spaceDim>(order); // bigN
212 this->basisDegree_ = order; // small n
213 this->basisCellTopologyKey_ = shards::Triangle<3>::key;
214 this->basisType_ = BASIS_FEM_LAGRANGIAN;
215 this->basisCoordinates_ = COORDINATES_CARTESIAN;
216 this->functionSpace_ = FUNCTION_SPACE_HGRAD;
217
218 pointType_ = (pointType == POINTTYPE_DEFAULT) ? POINTTYPE_EQUISPACED : pointType;
219 const ordinal_type card = this->basisCardinality_;
220
221 // points are computed in the host and will be copied
222 Kokkos::DynRankView<scalarType,typename DT::execution_space::array_layout,Kokkos::HostSpace>
223 dofCoords("Hgrad::Tri::Cn::dofCoords", card, spaceDim);
224
225 // construct lattice
226 const shards::CellTopology cellTopo(shards::getCellTopologyData<shards::Triangle<3>>());
227 const ordinal_type offset = 0;
228 PointTools::getLattice( dofCoords,
229 cellTopo,
230 order, offset,
231 this->pointType_ );
232
233 this->dofCoords_ = Kokkos::create_mirror_view(typename DT::memory_space(), dofCoords);
234 Kokkos::deep_copy(this->dofCoords_, dofCoords);
235
236 // form Vandermonde matrix. Actually, this is the transpose of the VDM,
237 // so we transpose on copy below.
238 const ordinal_type lwork = card*card;
239 Kokkos::DynRankView<scalarType,Kokkos::LayoutLeft,Kokkos::HostSpace>
240 vmat("Hgrad::Tri::Cn::vmat", card, card),
241 work("Hgrad::Tri::Cn::work", lwork),
242 ipiv("Hgrad::Tri::Cn::ipiv", card);
243
244 Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::getValues<Kokkos::HostSpace::execution_space,Parameters::MaxNumPtsPerBasisEval>(typename Kokkos::HostSpace::execution_space{},
245 vmat,
246 dofCoords,
247 order,
248 OPERATOR_VALUE);
249
250 ordinal_type info = 0;
251 Teuchos::LAPACK<ordinal_type,scalarType> lapack;
252
253 lapack.GETRF(card, card,
254 vmat.data(), vmat.stride(1),
255 (ordinal_type*)ipiv.data(),
256 &info);
257
258 INTREPID2_TEST_FOR_EXCEPTION( info != 0,
259 std::runtime_error ,
260 ">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM) lapack.GETRF returns nonzero info." );
261
262 lapack.GETRI(card,
263 vmat.data(), vmat.stride(1),
264 (ordinal_type*)ipiv.data(),
265 work.data(), lwork,
266 &info);
267
268 INTREPID2_TEST_FOR_EXCEPTION( info != 0,
269 std::runtime_error ,
270 ">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM) lapack.GETRI returns nonzero info." );
271
272 // create host mirror
273 Kokkos::DynRankView<scalarType,typename DT::execution_space::array_layout,Kokkos::HostSpace>
274 vinv("Hgrad::Line::Cn::vinv", card, card);
275
276 for (ordinal_type i=0;i<card;++i)
277 for (ordinal_type j=0;j<card;++j)
278 vinv(i,j) = vmat(j,i);
279
280 this->vinv_ = Kokkos::create_mirror_view(typename DT::memory_space(), vinv);
281 Kokkos::deep_copy(this->vinv_ , vinv);
282
283 // initialize tags
284 {
285 // Basis-dependent initializations
286 constexpr ordinal_type tagSize = 4; // size of DoF tag, i.e., number of fields in the tag
287 const ordinal_type posScDim = 0; // position in the tag, counting from 0, of the subcell dim
288 const ordinal_type posScOrd = 1; // position in the tag, counting from 0, of the subcell ordinal
289 const ordinal_type posDfOrd = 2; // position in the tag, counting from 0, of DoF ordinal relative to the subcell
290
291 // Note: the only reason why equispaced can't support higher order than Parameters::MaxOrder appears to be the fact that the tags below get stored into a fixed-length array.
292 // TODO: relax the maximum order requirement by setting up tags in a different container, perhaps directly into an OrdinalTypeArray1DHost (tagView, below). (As of this writing (1/25/22), looks like other nodal bases do this in a similar way -- those should be fixed at the same time; maybe search for Parameters::MaxOrder.)
293 INTREPID2_TEST_FOR_EXCEPTION( order > Parameters::MaxOrder, std::invalid_argument, "polynomial order exceeds the max supported by this class");
294 constexpr ordinal_type maxCard = Intrepid2::getPnCardinality<spaceDim, Parameters::MaxOrder>();
295 ordinal_type tags[maxCard][tagSize];
296
297 const ordinal_type
298 numEdgeDof = Intrepid2::getPnCardinality<1>(order-2),
299 numElemDof = (order > 2 ? Intrepid2::getPnCardinality<2>(order-3) : 0);
300
301 scalarType xi0, xi1, xi2;
302 const scalarType eps = threshold();
303
304 ordinal_type edgeId[3] = {}, elemId = 0;
305 for (ordinal_type i=0;i<card;++i) {
306
307 // compute barycentric coordinates
308 const auto x = dofCoords(i,0);
309 const auto y = dofCoords(i,1);
310 xi0 = 1.0 - x - y;
311 xi1= x;
312 xi2= y;
313
314 // vertex
315 if ((1.0 - xi0) < eps) { // vert 0
316 tags[i][0] = 0; // vertex dof
317 tags[i][1] = 0; // vertex id
318 tags[i][2] = 0; // local dof id
319 tags[i][3] = 1; // total vert dof
320 }
321 else if ((1.0 - xi1) < eps) { // vert 1
322 tags[i][0] = 0; // vertex dof
323 tags[i][1] = 1; // vertex id
324 tags[i][2] = 0; // local dof id
325 tags[i][3] = 1; // total vert dof
326 }
327 else if ((1.0 - xi2) < eps) { // vert 2
328 tags[i][0] = 0; // vertex dof
329 tags[i][1] = 2; // vertex id
330 tags[i][2] = 0; // local dof id
331 tags[i][3] = 1; // total vert dof
332 }
333 else if (xi2 < eps) { // edge 0
334 tags[i][0] = 1; // edge dof
335 tags[i][1] = 0; // edge id
336 tags[i][2] = edgeId[0]++; // local dof id
337 tags[i][3] = numEdgeDof; // total vert dof
338 }
339 else if (xi0 < eps) { // edge 1
340 tags[i][0] = 1; // edge dof
341 tags[i][1] = 1; // edge id
342 tags[i][2] = edgeId[1]++; // local dof id
343 tags[i][3] = numEdgeDof; // total vert dof
344 }
345 else if (xi1 < eps) { // edge 2
346 tags[i][0] = 1; // edge dof
347 tags[i][1] = 2; // edge id
348 tags[i][2] = edgeId[2]++; // local dof id
349 tags[i][3] = numEdgeDof; // total vert dof
350 }
351 else { // elem
352 tags[i][0] = 2; // intr dof
353 tags[i][1] = 0; // intr id
354 tags[i][2] = elemId++; // local dof id
355 tags[i][3] = numElemDof; // total vert dof
356 }
357 }
358
359 OrdinalTypeArray1DHost tagView(&tags[0][0], card*tagSize);
360
361 // Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
362 // tags are constructed on host
363 this->setOrdinalTagData(this->tagToOrdinal_,
364 this->ordinalToTag_,
365 tagView,
366 this->basisCardinality_,
367 tagSize,
368 posScDim,
369 posScOrd,
370 posDfOrd);
371 }
372}
373
374 template<typename DT, typename OT, typename PT>
375 void
376 Basis_HGRAD_TRI_Cn_FEM<DT,OT,PT>::getScratchSpaceSize(
377 ordinal_type& perTeamSpaceSize,
378 ordinal_type& perThreadSpaceSize,
379 const PointViewType inputPoints,
380 const EOperator operatorType) const {
381 perTeamSpaceSize = 0;
382 perThreadSpaceSize = getWorkSizePerPoint(operatorType)*get_dimension_scalar(inputPoints)*sizeof(typename BasisBase::scalarType);
383 }
384
385 template<typename DT, typename OT, typename PT>
386 KOKKOS_INLINE_FUNCTION
387 void
388 Basis_HGRAD_TRI_Cn_FEM<DT,OT,PT>::getValues(
389 OutputViewType outputValues,
390 const PointViewType inputPoints,
391 const EOperator operatorType,
392 const typename Kokkos::TeamPolicy<typename DT::execution_space>::member_type& team_member,
393 const typename DT::execution_space::scratch_memory_space & scratchStorage,
394 const ordinal_type subcellDim,
395 const ordinal_type subcellOrdinal) const {
396
397 INTREPID2_TEST_FOR_ABORT( !((subcellDim == -1) && (subcellOrdinal == -1)),
398 ">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM::getValues), The capability of selecting subsets of basis functions has not been implemented yet.");
399
400 const int numPoints = inputPoints.extent(0);
401 using ScalarType = typename ScalarTraits<typename PointViewType::value_type>::scalar_type;
402 using WorkViewType = Kokkos::DynRankView< ScalarType,typename DT::execution_space::scratch_memory_space,Kokkos::MemoryTraits<Kokkos::Unmanaged> >;
403 constexpr ordinal_type spaceDim = 2;
404 auto sizePerPoint = (operatorType==OPERATOR_VALUE) ?
405 this->vinv_.extent(0)*get_dimension_scalar(inputPoints) :
406 (2*spaceDim+1)*this->vinv_.extent(0)*get_dimension_scalar(inputPoints);
407 WorkViewType workView(scratchStorage, sizePerPoint*team_member.team_size());
408 using range_type = Kokkos::pair<ordinal_type,ordinal_type>;
409 switch(operatorType) {
410 case OPERATOR_VALUE:
411 Kokkos::parallel_for (Kokkos::TeamThreadRange (team_member, numPoints), [=, &vinv_ = this->vinv_, basisDegree_ = this->basisDegree_] (ordinal_type& pt) {
412 auto output = Kokkos::subview( outputValues, Kokkos::ALL(), range_type (pt,pt+1), Kokkos::ALL() );
413 const auto input = Kokkos::subview( inputPoints, range_type(pt, pt+1), Kokkos::ALL() );
414 WorkViewType work(workView.data() + sizePerPoint*team_member.team_rank(), sizePerPoint);
415 Impl::Basis_HGRAD_TRI_Cn_FEM::Serial<OPERATOR_VALUE>::getValues( output, input, work, vinv_, basisDegree_);
416 });
417 break;
418 case OPERATOR_GRAD:
419 Kokkos::parallel_for (Kokkos::TeamThreadRange (team_member, numPoints), [=, &vinv_ = this->vinv_, basisDegree_ = this->basisDegree_] (ordinal_type& pt) {
420 auto output = Kokkos::subview( outputValues, Kokkos::ALL(), range_type(pt,pt+1), Kokkos::ALL() );
421 const auto input = Kokkos::subview( inputPoints, range_type(pt,pt+1), Kokkos::ALL() );
422 WorkViewType work(workView.data() + sizePerPoint*team_member.team_rank(), sizePerPoint);
423 Impl::Basis_HGRAD_TRI_Cn_FEM::Serial<OPERATOR_GRAD>::getValues( output, input, work, vinv_, basisDegree_);
424 });
425 break;
426 case OPERATOR_CURL:
427 Kokkos::parallel_for (Kokkos::TeamThreadRange (team_member, numPoints), [=, &vinv_ = this->vinv_, basisDegree_ = this->basisDegree_] (ordinal_type& pt) {
428 auto output = Kokkos::subview( outputValues, Kokkos::ALL(), range_type(pt,pt+1), Kokkos::ALL() );
429 const auto input = Kokkos::subview( inputPoints, range_type(pt,pt+1), Kokkos::ALL() );
430 WorkViewType work(workView.data() + sizePerPoint*team_member.team_rank(), sizePerPoint);
431 Impl::Basis_HGRAD_TRI_Cn_FEM::Serial<OPERATOR_CURL>::getValues( output, input, work, vinv_, basisDegree_);
432 });
433 break;
434 default: {
435 INTREPID2_TEST_FOR_ABORT( true,
436 ">>> ERROR (Basis_HGRAD_TRI_Cn_FEM): getValues not implemented for this operator");
437 }
438 }
439 }
440
441} // namespace Intrepid2
442
443#endif
Intrepid2_HGRAD_TRI_Cn_FEM_ORTH.hpp
Header file for the Intrepid2::Basis_HGRAD_TRI_Cn_FEM_ORTH class.
Intrepid2::Basis_HGRAD_TRI_Cn_FEM::getScratchSpaceSize
virtual void getScratchSpaceSize(ordinal_type &perTeamSpaceSize, ordinal_type &perThreadSpaceSize, const PointViewType inputPoints, const EOperator operatorType=OPERATOR_VALUE) const override
Return the size of the scratch space, in bytes, needed for using the team-level implementation of get...
Definition Intrepid2_HGRAD_TRI_Cn_FEMDef.hpp:376
Intrepid2::Basis_HGRAD_TRI_Cn_FEM::Basis_HGRAD_TRI_Cn_FEM
Basis_HGRAD_TRI_Cn_FEM(const ordinal_type order, const EPointType pointType=POINTTYPE_EQUISPACED)
Constructor.
Definition Intrepid2_HGRAD_TRI_Cn_FEMDef.hpp:207
Intrepid2::Basis_HGRAD_TRI_Cn_FEM::getValues
virtual void getValues(const ExecutionSpace &space, OutputViewType outputValues, const PointViewType inputPoints, const EOperator operatorType=OPERATOR_VALUE) const override
Evaluation of a FEM basis on a reference cell.
Definition Intrepid2_HGRAD_TRI_Cn_FEM.hpp:190
Intrepid2::Basis::PointViewType
Kokkos::DynRankView< PointValueType, Kokkos::LayoutStride, DeviceType > PointViewType
View type for input points.
Definition Intrepid2_Basis.hpp:338
Intrepid2::Basis::scalarType
ScalarTraits< pointValueType >::scalar_type scalarType
Scalar type for point values.
Definition Intrepid2_Basis.hpp:157
Intrepid2::Basis::OrdinalTypeArray1DHost
Kokkos::View< ordinal_type *, typename ExecutionSpace::array_layout, Kokkos::HostSpace > OrdinalTypeArray1DHost
View type for 1d host array.
Definition Intrepid2_Basis.hpp:125
Intrepid2::Parameters::MaxOrder
static constexpr ordinal_type MaxOrder
The maximum reconstruction order.
Definition Intrepid2_Types.hpp:102
Intrepid2::PointTools::getLattice
static void getLattice(Kokkos::DynRankView< pointValueType, pointProperties... > points, const shards::CellTopology cellType, const ordinal_type order, const ordinal_type offset=0, const EPointType pointType=POINTTYPE_EQUISPACED)
Computes a lattice of points of a given order on a reference simplex, quadrilateral or hexahedron (cu...
Definition Intrepid2_PointToolsDef.hpp:86
Intrepid2::Impl::Basis_HGRAD_TRI_Cn_FEM::Serial
See Intrepid2::Basis_HGRAD_TRI_Cn_FEM work is a rank 1 view having the same value_type of inputPoints...
Definition Intrepid2_HGRAD_TRI_Cn_FEM.hpp:64
Generated by doxygen 1.9.8