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_View.hpp>
61 #include <Kokkos_DynRankView.hpp>
62 
64 
66 #include "Intrepid2_Sacado.hpp"
68 
69 namespace Intrepid2
70 {
71  template<class HGRAD_LINE, class HVOL_LINE>
73  :
74  public Basis_TensorBasis3<typename HGRAD_LINE::BasisBase>
75  {
76  public:
77  using OutputViewType = typename HGRAD_LINE::OutputViewType;
78  using PointViewType = typename HGRAD_LINE::PointViewType ;
79  using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
80 
81  using LineGradBasis = HGRAD_LINE;
82  using LineHVolBasis = HVOL_LINE;
83 
85  public:
92  Basis_Derived_HDIV_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType = POINTTYPE_DEFAULT)
93  :
94  TensorBasis3(Teuchos::rcp( new LineGradBasis(polyOrder_x,pointType)),
95  Teuchos::rcp( new LineHVolBasis(polyOrder_y-1,pointType)),
96  Teuchos::rcp( new LineHVolBasis(polyOrder_z-1,pointType)))
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  {
232  this->functionSpace_ = FUNCTION_SPACE_HDIV;
233  }
234 
237  virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator operatorType) const override
238  {
239  const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
240  const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
241  const EOperator DIV = Intrepid2::OPERATOR_DIV;
242 
243  const double weight = 1.0;
244  if (operatorType == VALUE)
245  {
246  std::vector< std::vector<EOperator> > ops(3);
247  ops[0] = std::vector<EOperator>{};
248  ops[1] = std::vector<EOperator>{VALUE,VALUE,VALUE};
249  ops[2] = std::vector<EOperator>{};
250  std::vector<double> weights {0.0,weight,0.0};
251  return OperatorTensorDecomposition(ops, weights);
252  }
253  else if (operatorType == DIV)
254  {
255  // family 2 is nonzero in the y component, so the div is (VALUE,GRAD,VALUE)
256  std::vector< std::vector<EOperator> > ops(1); // scalar value
257  ops[0] = std::vector<EOperator>{VALUE,GRAD,VALUE};
258  std::vector<double> weights {weight};
259  return OperatorTensorDecomposition(ops,weights);
260  }
261  else
262  {
263  INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
264  }
265  }
266 
268 
277  virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
278  const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3,
279  bool tensorPoints) const override
280  {
281  Intrepid2::EOperator op1, op2, op3;
282  if (operatorType == Intrepid2::OPERATOR_VALUE)
283  {
284  op1 = Intrepid2::OPERATOR_VALUE;
285  op2 = Intrepid2::OPERATOR_VALUE;
286  op3 = Intrepid2::OPERATOR_VALUE;
287 
288  // family 2 goes in the y component; 0 in the x and z components
289  auto outputValuesComponent_x = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
290  auto outputValuesComponent_y = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),1);
291  auto outputValuesComponent_z = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),2);
292 
293  // 0 in x component
294  Kokkos::deep_copy(outputValuesComponent_x,0.0);
295 
296  double weight = 1.0;
297  this->TensorBasis3::getValues(outputValuesComponent_y,
298  inputPoints1, op1,
299  inputPoints2, op2,
300  inputPoints3, op3, tensorPoints, weight);
301 
302  // 0 in z component
303  Kokkos::deep_copy(outputValuesComponent_z,0.0);
304  }
305  else if (operatorType == Intrepid2::OPERATOR_DIV)
306  {
307  // family 2 is nonzero in the y component, so the div is d/dy of the second component
308  op1 = Intrepid2::OPERATOR_VALUE;
309  op2 = Intrepid2::OPERATOR_GRAD; // d/dy
310  op3 = Intrepid2::OPERATOR_VALUE;
311 
312  double weight = 1.0;
313  this->TensorBasis3::getValues(outputValues,
314  inputPoints1, op1,
315  inputPoints2, op2,
316  inputPoints3, op3, tensorPoints, weight);
317  }
318  else
319  {
320  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
321  }
322  }
323 
335  virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
336  auto dofCoeffs1 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),0);
337  auto dofCoeffs2 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),1);
338  auto dofCoeffs3 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),2);
339  Kokkos::deep_copy(dofCoeffs1,0.0);
340  this->TensorBasis3::getDofCoeffs(dofCoeffs2);
341  Kokkos::deep_copy(dofCoeffs3,0.0);
342  }
343  };
344 
345  template<class HGRAD_LINE, class HVOL_LINE>
347  : public Basis_TensorBasis3<typename HGRAD_LINE::BasisBase>
348  {
349  public:
350  using OutputViewType = typename HGRAD_LINE::OutputViewType;
351  using PointViewType = typename HGRAD_LINE::PointViewType ;
352  using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
353 
354  using LineGradBasis = HGRAD_LINE;
355  using LineHVolBasis = HVOL_LINE;
356 
358  public:
365  Basis_Derived_HDIV_Family3_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType = POINTTYPE_DEFAULT)
366  :
367  TensorBasis3(Teuchos::rcp( new LineHVolBasis(polyOrder_x-1,pointType) ),
368  Teuchos::rcp( new LineHVolBasis(polyOrder_y-1,pointType) ),
369  Teuchos::rcp( new LineGradBasis(polyOrder_z,pointType) ))
370  {
371  this->functionSpace_ = FUNCTION_SPACE_HDIV;
372  }
373 
376  virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator operatorType) const override
377  {
378  const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
379  const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
380  const EOperator DIV = Intrepid2::OPERATOR_DIV;
381 
382  const double weight = 1.0;
383  if (operatorType == VALUE)
384  {
385  std::vector< std::vector<EOperator> > ops(3);
386  ops[0] = std::vector<EOperator>{};
387  ops[1] = std::vector<EOperator>{};
388  ops[2] = std::vector<EOperator>{VALUE,VALUE,VALUE};
389  std::vector<double> weights {0.0,0.0,weight};
390  return OperatorTensorDecomposition(ops, weights);
391  }
392  else if (operatorType == DIV)
393  {
394  // family 3 is nonzero in the z component, so the div is (VALUE,VALUE,GRAD)
395  std::vector< std::vector<EOperator> > ops(1); // scalar value
396  ops[0] = std::vector<EOperator>{VALUE,VALUE,GRAD};
397  std::vector<double> weights {weight};
398  return OperatorTensorDecomposition(ops,weights);
399  }
400  else
401  {
402  INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
403  }
404  }
405 
407 
416  virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
417  const PointViewType inputPoints1, const PointViewType inputPoints2, const PointViewType inputPoints3,
418  bool tensorPoints) const override
419  {
420  Intrepid2::EOperator op1, op2, op3;
421  if (operatorType == Intrepid2::OPERATOR_VALUE)
422  {
423  op1 = Intrepid2::OPERATOR_VALUE;
424  op2 = Intrepid2::OPERATOR_VALUE;
425  op3 = Intrepid2::OPERATOR_VALUE;
426 
427  // family 3 goes in the z component; 0 in the x and y components
428  auto outputValuesComponent_xy = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),std::make_pair(0,2));
429  auto outputValuesComponent_z = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),2);
430 
431  // 0 in x and y components
432  Kokkos::deep_copy(outputValuesComponent_xy,0.0);
433 
434  // z component
435  this->TensorBasis3::getValues(outputValuesComponent_z,
436  inputPoints1, op1,
437  inputPoints2, op2,
438  inputPoints3, op3, tensorPoints);
439  }
440  else if (operatorType == Intrepid2::OPERATOR_DIV)
441  {
442  // family 3 is nonzero in the z component, so the div is d/dz of the third component
443  // outputValues is scalar, so no need to take subviews
444 
445  op1 = Intrepid2::OPERATOR_VALUE;
446  op2 = Intrepid2::OPERATOR_VALUE;
447  op3 = Intrepid2::OPERATOR_GRAD; // d/dz
448 
449  double weight = 1.0; // the plus sign in front of d/dz
450  this->TensorBasis3::getValues(outputValues,
451  inputPoints1, op1,
452  inputPoints2, op2,
453  inputPoints3, op3, tensorPoints, weight);
454  }
455  else
456  {
457  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
458  }
459  }
460 
472  virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
473  auto dofCoeffs12 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),std::make_pair(0,2));
474  auto dofCoeffs3 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),2);
475  Kokkos::deep_copy(dofCoeffs12,0.0);
476  this->TensorBasis3::getDofCoeffs(dofCoeffs3);
477  }
478 
479  };
480 
481  // ESEAS numbers its H(div) families differently, with the nonzero going in z, x, y for I,II,III.
482  // To allow our interior orderings to match that of ESEAS, we put the direct sum in the same order as ESEAS,
483  // which is to say that we go 3,1,2.
484  template<class HGRAD_LINE, class HVOL_LINE>
486  : public Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>
487  {
491  public:
498  Basis_Derived_HDIV_Family3_Family1_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType)
499  :
500  DirectSumBasis(Teuchos::rcp( new Family3(polyOrder_x, polyOrder_y, polyOrder_z, pointType)),
501  Teuchos::rcp( new Family1(polyOrder_x, polyOrder_y, polyOrder_z, pointType))) {
502  this->functionSpace_ = FUNCTION_SPACE_HDIV;
503  }
504  };
505 
506  template<class HGRAD_LINE, class HVOL_LINE>
508  : public Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>
509  {
513 
514  std::string name_;
515  ordinal_type order_x_;
516  ordinal_type order_y_;
517  ordinal_type order_z_;
518  EPointType pointType_;
519 
520  public:
521  using ExecutionSpace = typename HGRAD_LINE::ExecutionSpace;
522  using OutputValueType = typename HGRAD_LINE::OutputValueType;
523  using PointValueType = typename HGRAD_LINE::PointValueType;
524 
525  using BasisBase = typename HGRAD_LINE::BasisBase;
526 
533  Basis_Derived_HDIV_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
534  :
535  DirectSumBasis(Teuchos::rcp(new Family31(polyOrder_x, polyOrder_y, polyOrder_z, pointType)),
536  Teuchos::rcp(new Family2 (polyOrder_x, polyOrder_y, polyOrder_z, pointType))) {
537  this->functionSpace_ = FUNCTION_SPACE_HDIV;
538 
539  std::ostringstream basisName;
540  basisName << "HDIV_HEX (" << this->DirectSumBasis::getName() << ")";
541  name_ = basisName.str();
542 
543  order_x_ = polyOrder_x;
544  order_y_ = polyOrder_y;
545  order_z_ = polyOrder_z;
546  pointType_ = pointType;
547  }
548 
552  Basis_Derived_HDIV_HEX(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT) : Basis_Derived_HDIV_HEX(polyOrder, polyOrder, polyOrder, pointType) {}
553 
556  virtual bool requireOrientation() const override {
557  return (this->getDofCount(2,0) > 0); //if it has side DOFs, than it needs orientations
558  }
559 
564  virtual
565  const char*
566  getName() const override {
567  return name_.c_str();
568  }
569 
580  Teuchos::RCP<BasisBase>
581  getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override {
582 
583  using QuadBasis = Basis_Derived_HVOL_QUAD<HVOL_LINE>;
584 
585  if(subCellDim == 2) {
586  switch(subCellOrd) {
587  case 0:
588  return Teuchos::rcp( new QuadBasis(order_x_-1, order_z_-1, pointType_) );
589  case 1:
590  return Teuchos::rcp( new QuadBasis(order_y_-1,order_z_-1, pointType_) );
591  case 2:
592  return Teuchos::rcp( new QuadBasis(order_x_-1, order_z_-1, pointType_) );
593  case 3:
594  return Teuchos::rcp( new QuadBasis(order_z_-1, order_y_-1, pointType_) );
595  case 4:
596  return Teuchos::rcp( new QuadBasis(order_y_-1, order_x_-1, pointType_) );
597  case 5:
598  return Teuchos::rcp( new QuadBasis(order_x_-1, order_y_-1, pointType_) );
599  }
600  }
601 
602  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"Input parameters out of bounds");
603  }
604 
610  getHostBasis() const override {
612 
613  auto hostBasis = Teuchos::rcp(new HostBasis(order_x_, order_y_, order_z_, pointType_));
614 
615  return hostBasis;
616  }
617  };
618 } // end namespace Intrepid2
619 
620 #endif /* Intrepid2_DerivedBasis_HDIV_HEX_h */
Implementation of bases that are tensor products of two or three component bases. ...
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)
Implementation of H(vol) basis on the quadrilateral that is templated on H(vol) on the line...
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_Family2_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
Free functions, callable from device code, that implement various polynomials useful in basis definit...
For a multi-component tensor basis, specifies the operators to be applied to the components to produc...
virtual HostBasisPtr< OutputValueType, PointValueType > getHostBasis() const override
Creates and returns a Basis object whose DeviceType template argument is Kokkos::HostSpace::device_ty...
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 const char * getName() const override
Returns basis name.
Implementation of a basis that is the direct sum of two other bases.
BasisPtr< typename Kokkos::HostSpace::device_type, OutputType, PointType > HostBasisPtr
Pointer to a Basis whose device type is on the host (Kokkos::HostSpace::device_type), allowing host access to input and output views, and ensuring host execution of basis evaluation.
virtual void getDofCoeffs(typename BasisBase::ScalarViewType dofCoeffs) const override
Fills in coefficients of degrees of freedom on the reference cell.
virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator operatorType) const override
Returns a simple decomposition of the specified operator: what operator(s) should be applied to basis...
A basis that is the direct sum of two other bases.
virtual const char * getName() const override
Returns basis name.
virtual bool requireOrientation() const override
True if orientation is required.
EOperator
Enumeration of primitive operators available in Intrepid. Primitive operators act on reconstructed fu...
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_HEX(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
Basis_Derived_HDIV_HEX(int polyOrder_x, int polyOrder_y, int polyOrder_z, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
EPointType
Enumeration of types of point distributions in Intrepid.
Header file to include all Sacado headers that are required if using Intrepid2 with Sacado types...
Basis_Derived_HDIV_Family3_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...
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)
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.
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...
Teuchos::RCP< BasisBase > getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override
returns the basis associated to a subCell.