Intrepid2
Intrepid2_DerivedBasis_HDIV_HEX.hpp
Go to the documentation of this file.
1// @HEADER
2// ************************************************************************
3//
4// Intrepid2 Package
5// Copyright (2007) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Kyungjoo Kim (kyukim@sandia.gov),
38// Mauro Perego (mperego@sandia.gov), or
39// Nate Roberts (nvrober@sandia.gov)
40//
41// ************************************************************************
42// @HEADER
43
57#ifndef Intrepid2_DerivedBasis_HDIV_HEX_h
58#define Intrepid2_DerivedBasis_HDIV_HEX_h
59
60#include <Kokkos_DynRankView.hpp>
61
63
65#include "Intrepid2_Sacado.hpp"
67
68namespace Intrepid2
69{
70 template<class HGRAD_LINE, class HVOL_LINE>
72 :
73 public Basis_TensorBasis3<typename HGRAD_LINE::BasisBase>
74 {
75 public:
76 using OutputViewType = typename HGRAD_LINE::OutputViewType;
77 using PointViewType = typename HGRAD_LINE::PointViewType ;
78 using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
79
80 using LineGradBasis = HGRAD_LINE;
81 using LineHVolBasis = HVOL_LINE;
82
84 public:
91 Basis_Derived_HDIV_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType = POINTTYPE_DEFAULT)
92 :
93 TensorBasis3(Teuchos::rcp( new LineGradBasis(polyOrder_x,pointType)),
94 Teuchos::rcp( new LineHVolBasis(polyOrder_y-1,pointType)),
95 Teuchos::rcp( new LineHVolBasis(polyOrder_z-1,pointType)),
96 true) // true: use shards CellTopology and tags
97 {
98 this->functionSpace_ = FUNCTION_SPACE_HDIV;
99 }
100
103 virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
104 {
105 const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
106 const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
107 const EOperator DIV = Intrepid2::OPERATOR_DIV;
108
109 const double weight = 1.0;
110 if (operatorType == VALUE)
111 {
112 std::vector< std::vector<EOperator> > ops(3);
113 ops[0] = std::vector<EOperator>{VALUE,VALUE,VALUE};
114 ops[1] = std::vector<EOperator>{};
115 ops[2] = std::vector<EOperator>{};
116 std::vector<double> weights {weight,0.0,0.0};
117 return OperatorTensorDecomposition(ops, weights);
118 }
119 else if (operatorType == DIV)
120 {
121 // family 1 is nonzero in the x component, so the div is (GRAD,VALUE,VALUE)
122 std::vector< std::vector<EOperator> > ops(1); // scalar value
123 ops[0] = std::vector<EOperator>{GRAD,VALUE,VALUE};
124 std::vector<double> weights {weight};
125 return OperatorTensorDecomposition(ops,weights);
126 }
127 else
128 {
129 INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
130 }
131 }
132
134
143 virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
144 const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3,
145 bool tensorPoints) const override
146 {
147 Intrepid2::EOperator op1, op2, op3;
148 if (operatorType == Intrepid2::OPERATOR_VALUE)
149 {
150 op1 = Intrepid2::OPERATOR_VALUE;
151 op2 = Intrepid2::OPERATOR_VALUE;
152 op3 = Intrepid2::OPERATOR_VALUE;
153
154 // family 1 goes in the x component; 0 in the y and z components
155 auto outputValuesComponent1 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
156 auto outputValuesComponent23 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),std::make_pair(1,3));
157
158 this->TensorBasis3::getValues(outputValuesComponent1,
159 inputPoints1, op1,
160 inputPoints2, op2,
161 inputPoints3, op3, tensorPoints);
162 // place 0 in the y and z components
163 Kokkos::deep_copy(outputValuesComponent23,0.0);
164 }
165 else if (operatorType == Intrepid2::OPERATOR_DIV)
166 {
167 // family 1 is nonzero in the x component, so the div is d/dx of the first component
168 // outputValues is scalar, so no need to take subviews
169
170 op1 = Intrepid2::OPERATOR_GRAD; // d/dx
171 op2 = Intrepid2::OPERATOR_VALUE;
172 op3 = Intrepid2::OPERATOR_VALUE;
173
174 double weight = 1.0; // the plus sign in front of d/dx
175 this->TensorBasis3::getValues(outputValues,
176 inputPoints1, op1,
177 inputPoints2, op2,
178 inputPoints3, op3, tensorPoints, weight);
179 }
180 else
181 {
182 INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
183 }
184 }
185
197 virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
198 auto dofCoeffs1 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),0);
199 auto dofCoeffs23 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),std::make_pair(1,3));
200 this->TensorBasis3::getDofCoeffs(dofCoeffs1);
201 Kokkos::deep_copy(dofCoeffs23,0.0);
202 }
203 };
204
205 template<class HGRAD_LINE, class HVOL_LINE>
207 :
208 public Basis_TensorBasis3<typename HGRAD_LINE::BasisBase>
209 {
210 public:
211 using OutputViewType = typename HGRAD_LINE::OutputViewType;
212 using PointViewType = typename HGRAD_LINE::PointViewType ;
213 using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
214
215 using LineGradBasis = HGRAD_LINE;
216 using LineHVolBasis = HVOL_LINE;
217
219 public:
226 Basis_Derived_HDIV_Family2_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType = POINTTYPE_DEFAULT)
227 :
228 TensorBasis3(Teuchos::rcp( new LineHVolBasis(polyOrder_x-1,pointType) ),
229 Teuchos::rcp( new LineGradBasis(polyOrder_y,pointType) ),
230 Teuchos::rcp( new LineHVolBasis(polyOrder_z-1,pointType) ),
231 true) // true: use shards CellTopology and tags
232 {
233 this->functionSpace_ = FUNCTION_SPACE_HDIV;
234 }
235
238 virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
239 {
240 const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
241 const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
242 const EOperator DIV = Intrepid2::OPERATOR_DIV;
243
244 const double weight = 1.0;
245 if (operatorType == VALUE)
246 {
247 std::vector< std::vector<EOperator> > ops(3);
248 ops[0] = std::vector<EOperator>{};
249 ops[1] = std::vector<EOperator>{VALUE,VALUE,VALUE};
250 ops[2] = std::vector<EOperator>{};
251 std::vector<double> weights {0.0,weight,0.0};
252 return OperatorTensorDecomposition(ops, weights);
253 }
254 else if (operatorType == DIV)
255 {
256 // family 2 is nonzero in the y component, so the div is (VALUE,GRAD,VALUE)
257 std::vector< std::vector<EOperator> > ops(1); // scalar value
258 ops[0] = std::vector<EOperator>{VALUE,GRAD,VALUE};
259 std::vector<double> weights {weight};
260 return OperatorTensorDecomposition(ops,weights);
261 }
262 else
263 {
264 INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
265 }
266 }
267
269
278 virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
279 const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3,
280 bool tensorPoints) const override
281 {
282 Intrepid2::EOperator op1, op2, op3;
283 if (operatorType == Intrepid2::OPERATOR_VALUE)
284 {
285 op1 = Intrepid2::OPERATOR_VALUE;
286 op2 = Intrepid2::OPERATOR_VALUE;
287 op3 = Intrepid2::OPERATOR_VALUE;
288
289 // family 2 goes in the y component; 0 in the x and z components
290 auto outputValuesComponent_x = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
291 auto outputValuesComponent_y = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),1);
292 auto outputValuesComponent_z = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),2);
293
294 // 0 in x component
295 Kokkos::deep_copy(outputValuesComponent_x,0.0);
296
297 double weight = 1.0;
298 this->TensorBasis3::getValues(outputValuesComponent_y,
299 inputPoints1, op1,
300 inputPoints2, op2,
301 inputPoints3, op3, tensorPoints, weight);
302
303 // 0 in z component
304 Kokkos::deep_copy(outputValuesComponent_z,0.0);
305 }
306 else if (operatorType == Intrepid2::OPERATOR_DIV)
307 {
308 // family 2 is nonzero in the y component, so the div is d/dy of the second component
309 op1 = Intrepid2::OPERATOR_VALUE;
310 op2 = Intrepid2::OPERATOR_GRAD; // d/dy
311 op3 = Intrepid2::OPERATOR_VALUE;
312
313 double weight = 1.0;
314 this->TensorBasis3::getValues(outputValues,
315 inputPoints1, op1,
316 inputPoints2, op2,
317 inputPoints3, op3, tensorPoints, weight);
318 }
319 else
320 {
321 INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
322 }
323 }
324
336 virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
337 auto dofCoeffs1 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),0);
338 auto dofCoeffs2 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),1);
339 auto dofCoeffs3 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),2);
340 Kokkos::deep_copy(dofCoeffs1,0.0);
341 this->TensorBasis3::getDofCoeffs(dofCoeffs2);
342 Kokkos::deep_copy(dofCoeffs3,0.0);
343 }
344 };
345
346 template<class HGRAD_LINE, class HVOL_LINE>
348 : public Basis_TensorBasis3<typename HGRAD_LINE::BasisBase>
349 {
350 public:
351 using OutputViewType = typename HGRAD_LINE::OutputViewType;
352 using PointViewType = typename HGRAD_LINE::PointViewType ;
353 using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
354
355 using LineGradBasis = HGRAD_LINE;
356 using LineHVolBasis = HVOL_LINE;
357
359 public:
366 Basis_Derived_HDIV_Family3_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType = POINTTYPE_DEFAULT)
367 :
368 TensorBasis3(Teuchos::rcp( new LineHVolBasis(polyOrder_x-1,pointType) ),
369 Teuchos::rcp( new LineHVolBasis(polyOrder_y-1,pointType) ),
370 Teuchos::rcp( new LineGradBasis(polyOrder_z,pointType) ),
371 true) // true: use shards CellTopology and tags
372 {
373 this->functionSpace_ = FUNCTION_SPACE_HDIV;
374 }
375
378 virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
379 {
380 const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
381 const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
382 const EOperator DIV = Intrepid2::OPERATOR_DIV;
383
384 const double weight = 1.0;
385 if (operatorType == VALUE)
386 {
387 std::vector< std::vector<EOperator> > ops(3);
388 ops[0] = std::vector<EOperator>{};
389 ops[1] = std::vector<EOperator>{};
390 ops[2] = std::vector<EOperator>{VALUE,VALUE,VALUE};
391 std::vector<double> weights {0.0,0.0,weight};
392 return OperatorTensorDecomposition(ops, weights);
393 }
394 else if (operatorType == DIV)
395 {
396 // family 3 is nonzero in the z component, so the div is (VALUE,VALUE,GRAD)
397 std::vector< std::vector<EOperator> > ops(1); // scalar value
398 ops[0] = std::vector<EOperator>{VALUE,VALUE,GRAD};
399 std::vector<double> weights {weight};
400 return OperatorTensorDecomposition(ops,weights);
401 }
402 else
403 {
404 INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
405 }
406 }
407
409
418 virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
419 const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3,
420 bool tensorPoints) const override
421 {
422 Intrepid2::EOperator op1, op2, op3;
423 if (operatorType == Intrepid2::OPERATOR_VALUE)
424 {
425 op1 = Intrepid2::OPERATOR_VALUE;
426 op2 = Intrepid2::OPERATOR_VALUE;
427 op3 = Intrepid2::OPERATOR_VALUE;
428
429 // family 3 goes in the z component; 0 in the x and y components
430 auto outputValuesComponent_xy = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),std::make_pair(0,2));
431 auto outputValuesComponent_z = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),2);
432
433 // 0 in x and y components
434 Kokkos::deep_copy(outputValuesComponent_xy,0.0);
435
436 // z component
437 this->TensorBasis3::getValues(outputValuesComponent_z,
438 inputPoints1, op1,
439 inputPoints2, op2,
440 inputPoints3, op3, tensorPoints);
441 }
442 else if (operatorType == Intrepid2::OPERATOR_DIV)
443 {
444 // family 3 is nonzero in the z component, so the div is d/dz of the third component
445 // outputValues is scalar, so no need to take subviews
446
447 op1 = Intrepid2::OPERATOR_VALUE;
448 op2 = Intrepid2::OPERATOR_VALUE;
449 op3 = Intrepid2::OPERATOR_GRAD; // d/dz
450
451 double weight = 1.0; // the plus sign in front of d/dz
452 this->TensorBasis3::getValues(outputValues,
453 inputPoints1, op1,
454 inputPoints2, op2,
455 inputPoints3, op3, tensorPoints, weight);
456 }
457 else
458 {
459 INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
460 }
461 }
462
474 virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
475 auto dofCoeffs12 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),std::make_pair(0,2));
476 auto dofCoeffs3 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),2);
477 Kokkos::deep_copy(dofCoeffs12,0.0);
478 this->TensorBasis3::getDofCoeffs(dofCoeffs3);
479 }
480
481 };
482
483 // ESEAS numbers its H(div) families differently, with the nonzero going in z, x, y for I,II,III.
484 // To allow our interior orderings to match that of ESEAS, we put the direct sum in the same order as ESEAS,
485 // which is to say that we go 3,1,2.
486 template<class HGRAD_LINE, class HVOL_LINE>
488 : public Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>
489 {
493 public:
500 Basis_Derived_HDIV_Family3_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType)
501 :
502 DirectSumBasis(Teuchos::rcp( new Family3(polyOrder_x, polyOrder_y, polyOrder_z, pointType)),
503 Teuchos::rcp( new Family1(polyOrder_x, polyOrder_y, polyOrder_z, pointType))) {
504 this->functionSpace_ = FUNCTION_SPACE_HDIV;
505 }
506 };
507
508 template<class HGRAD_LINE, class HVOL_LINE>
510 : public Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>
511 {
513 using Family2 = Basis_Derived_HDIV_Family2_HEX <HGRAD_LINE, HVOL_LINE>;
515
516 std::string name_;
517 ordinal_type order_x_;
518 ordinal_type order_y_;
519 ordinal_type order_z_;
520 EPointType pointType_;
521
522 public:
523 using ExecutionSpace = typename HGRAD_LINE::ExecutionSpace;
524 using OutputValueType = typename HGRAD_LINE::OutputValueType;
525 using PointValueType = typename HGRAD_LINE::PointValueType;
526
527 using BasisBase = typename HGRAD_LINE::BasisBase;
528
535 Basis_Derived_HDIV_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
536 :
537 DirectSumBasis(Teuchos::rcp(new Family31(polyOrder_x, polyOrder_y, polyOrder_z, pointType)),
538 Teuchos::rcp(new Family2 (polyOrder_x, polyOrder_y, polyOrder_z, pointType))) {
539 this->functionSpace_ = FUNCTION_SPACE_HDIV;
540
541 std::ostringstream basisName;
542 basisName << "HDIV_HEX (" << this->DirectSumBasis::getName() << ")";
543 name_ = basisName.str();
544
545 order_x_ = polyOrder_x;
546 order_y_ = polyOrder_y;
547 order_z_ = polyOrder_z;
548 pointType_ = pointType;
549 }
550
554 Basis_Derived_HDIV_HEX(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT) : Basis_Derived_HDIV_HEX(polyOrder, polyOrder, polyOrder, pointType) {}
555
558 virtual bool requireOrientation() const override {
559 return true;
560 }
561
566 virtual
567 const char*
568 getName() const override {
569 return name_.c_str();
570 }
571
582 Teuchos::RCP<BasisBase>
583 getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override {
584
585 using QuadBasis = Basis_Derived_HVOL_QUAD<HVOL_LINE>;
586
587 if(subCellDim == 2) {
588 switch(subCellOrd) {
589 case 0:
590 return Teuchos::rcp( new QuadBasis(order_x_-1, order_z_-1, pointType_) );
591 case 1:
592 return Teuchos::rcp( new QuadBasis(order_y_-1,order_z_-1, pointType_) );
593 case 2:
594 return Teuchos::rcp( new QuadBasis(order_x_-1, order_z_-1, pointType_) );
595 case 3:
596 return Teuchos::rcp( new QuadBasis(order_z_-1, order_y_-1, pointType_) );
597 case 4:
598 return Teuchos::rcp( new QuadBasis(order_y_-1, order_x_-1, pointType_) );
599 case 5:
600 return Teuchos::rcp( new QuadBasis(order_x_-1, order_y_-1, pointType_) );
601 }
602 }
603
604 INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"Input parameters out of bounds");
605 }
606
612 getHostBasis() const override {
614
615 auto hostBasis = Teuchos::rcp(new HostBasis(order_x_, order_y_, order_z_, pointType_));
616
617 return hostBasis;
618 }
619 };
620} // end namespace Intrepid2
621
622#endif /* Intrepid2_DerivedBasis_HDIV_HEX_h */
BasisPtr< typename Kokkos::HostSpace::device_type, OutputType, PointType > HostBasisPtr
Pointer to a Basis whose device type is on the host (Kokkos::HostSpace::device_type),...
Implementation of a basis that is the direct sum of two other bases.
Free functions, callable from device code, that implement various polynomials useful in basis definit...
Header file to include all Sacado headers that are required if using Intrepid2 with Sacado types.
Implementation of bases that are tensor products of two or three component bases.
virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
Returns a simple decomposition of the specified operator: what operator(s) should be applied to basis...
virtual void getDofCoeffs(ScalarViewType dofCoeffs) const override
Fills in coefficients of degrees of freedom for Lagrangian basis on the reference cell.
virtual void getValues(OutputViewType outputValues, const EOperator operatorType, const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3, bool tensorPoints) const override
multi-component getValues() method (required/called by TensorBasis3)
Basis_Derived_HDIV_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
virtual void getDofCoeffs(ScalarViewType dofCoeffs) const override
Fills in coefficients of degrees of freedom for Lagrangian basis on the reference cell.
Basis_Derived_HDIV_Family2_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
virtual void getValues(OutputViewType outputValues, const EOperator operatorType, const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3, bool tensorPoints) const override
multi-component getValues() method (required/called by TensorBasis3)
virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
Returns a simple decomposition of the specified operator: what operator(s) should be applied to basis...
Basis_Derived_HDIV_Family3_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType)
Constructor.
virtual void getDofCoeffs(ScalarViewType dofCoeffs) const override
Fills in coefficients of degrees of freedom for Lagrangian basis on the reference cell.
Basis_Derived_HDIV_Family3_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
Returns a simple decomposition of the specified operator: what operator(s) should be applied to basis...
virtual void getValues(OutputViewType outputValues, const EOperator operatorType, const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3, bool tensorPoints) const override
multi-component getValues() method (required/called by TensorBasis3)
Basis_Derived_HDIV_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
virtual HostBasisPtr< OutputValueType, PointValueType > getHostBasis() const override
Creates and returns a Basis object whose DeviceType template argument is Kokkos::HostSpace::device_ty...
Teuchos::RCP< BasisBase > getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override
returns the basis associated to a subCell.
virtual const char * getName() const override
Returns basis name.
virtual bool requireOrientation() const override
True if orientation is required.
Basis_Derived_HDIV_HEX(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
Implementation of H(vol) basis on the quadrilateral that is templated on H(vol) on the line.
A basis that is the direct sum of two other bases.
virtual const char * getName() const override
Returns basis name.
virtual void getValues(OutputViewType outputValues, const EOperator operatorType, const PointViewType inputPoints12, const PointViewType inputPoints3, bool tensorPoints) const override
Evaluation of a tensor FEM basis on a reference cell.
virtual void getDofCoeffs(typename BasisBase::ScalarViewType dofCoeffs) const override
Fills in coefficients of degrees of freedom on the reference cell.
For a multi-component tensor basis, specifies the operators to be applied to the components to produc...