Intrepid2
Intrepid2_DerivedBasis_HGRAD_QUAD.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 
51 #ifndef Intrepid2_DerivedBasis_HGRAD_QUAD_h
52 #define Intrepid2_DerivedBasis_HGRAD_QUAD_h
53 
55 
56 namespace Intrepid2
57 {
58  template<class HGRAD_LINE>
60  : public Basis_TensorBasis<typename HGRAD_LINE::BasisBase>
61  {
62  protected:
63  std::string name_;
64  ordinal_type order_x_, order_y_;
65  EPointType pointType_;
66  public:
67  using ExecutionSpace = typename HGRAD_LINE::ExecutionSpace;
68  using OutputValueType = typename HGRAD_LINE::OutputValueType;
69  using PointValueType = typename HGRAD_LINE::PointValueType;
70 
71  using OutputViewType = typename HGRAD_LINE::OutputViewType;
72  using PointViewType = typename HGRAD_LINE::PointViewType ;
73  using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
74 
75  using BasisBase = typename HGRAD_LINE::BasisBase;
76  using LineBasis = HGRAD_LINE;
78 
84  Basis_Derived_HGRAD_QUAD(int polyOrder_x, int polyOrder_y, const EPointType pointType=POINTTYPE_DEFAULT)
85  :
86  TensorBasis(Teuchos::rcp( new LineBasis(polyOrder_x, pointType)),
87  Teuchos::rcp( new LineBasis(polyOrder_y, pointType)))
88  {
89  this->functionSpace_ = FUNCTION_SPACE_HGRAD;
90 
91  std::ostringstream basisName;
92  basisName << "HGRAD_QUAD (" << this->TensorBasis::getName() << ")";
93  name_ = basisName.str();
94 
95  order_x_= polyOrder_x;
96  order_y_ = polyOrder_x;
97  pointType_ = pointType;
98  }
99 
104  Basis_Derived_HGRAD_QUAD(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT) : Basis_Derived_HGRAD_QUAD(polyOrder,polyOrder,pointType) {}
105 
106 
109  virtual bool requireOrientation() const override {
110  return (this->getDofCount(1,0) > 1); //if it has more than 1 DOF per edge, than it needs orientations
111  }
112 
115  virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator operatorType) const override
116  {
117  const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
118  const EOperator GRAD = Intrepid2::OPERATOR_GRAD;
119 
120  if (operatorType == VALUE)
121  {
122  return OperatorTensorDecomposition(Intrepid2::OPERATOR_VALUE,Intrepid2::OPERATOR_VALUE);
123  }
124  else if (operatorType == GRAD)
125  {
126  // to evaluate gradient, we need both OP_VALUE and OP_GRAD (thanks to product rule)
127  // for 1D line x line, we will put derivative * value in first component, and value * derivative in second
128 
129  std::vector< std::vector<EOperator> > ops;
130  ops.push_back(std::vector<EOperator>{GRAD, VALUE});
131  ops.push_back(std::vector<EOperator>{VALUE, GRAD});
132 
133  std::vector<double> weights(ops.size(), 1.0);
134 
135  return OperatorTensorDecomposition(ops, weights);
136  }
137  else
138  {
139  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
140  }
141  }
142 
143  using BasisBase::getValues;
144 
152  virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
153  const PointViewType inputPoints1, const PointViewType inputPoints2,
154  bool tensorPoints) const override
155  {
156  Intrepid2::EOperator op1, op2;
157  if (operatorType == Intrepid2::OPERATOR_VALUE)
158  {
159  op1 = Intrepid2::OPERATOR_VALUE;
160  op2 = Intrepid2::OPERATOR_VALUE;
161 
162  this->TensorBasis::getValues(outputValues,
163  inputPoints1, op1,
164  inputPoints2, op2, tensorPoints);
165  }
166  else if (operatorType == Intrepid2::OPERATOR_GRAD)
167  {
168  // to evaluate gradient, we actually need both OP_VALUE and OP_GRAD (thanks to product rule)
169  // for 1D line x line, we will put derivative * value in first component, and value * derivative in second
170 
171  // outputValues1 and outputValues2 are computed by basis1 and basis2 -- these are tensorial components
172  // outputValuesComponent1 is a slice of the final output container (similarly, outputValuesComponent2)
173  // when the component basis is 1D, it expects not to have a "dimension" component in the output container
174  // the int argument in the dimension component creates a subview that skips the dimension component; the std::pair argument retains it
175  auto outputValuesComponent1 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
176  auto outputValuesComponent2 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),1);
177 
178  // compute first component -- derivative happens in x, and value taken in y
179  op1 = Intrepid2::OPERATOR_GRAD;
180  op2 = Intrepid2::OPERATOR_VALUE;
181 
182  this->TensorBasis::getValues(outputValuesComponent1,
183  inputPoints1, op1,
184  inputPoints2, op2, tensorPoints);
185 
186  // second component -- value in x, derivative in y
187  op1 = Intrepid2::OPERATOR_VALUE;
188  op2 = Intrepid2::OPERATOR_GRAD;
189 
190  this->TensorBasis::getValues(outputValuesComponent2,
191  inputPoints1, op1,
192  inputPoints2, op2, tensorPoints);
193  }
194  else
195  {
196  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
197  }
198  }
199 
200 
205  virtual
206  const char*
207  getName() const override {
208  return name_.c_str();
209  }
210 
220  Teuchos::RCP<BasisBase>
221  getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override{
222  if(subCellDim == 1) {
223  switch(subCellOrd) {
224  case 0:
225  case 2:
226  return Teuchos::rcp( new LineBasis(order_x_, pointType_) );
227  case 1:
228  case 3:
229  return Teuchos::rcp( new LineBasis(order_y_, pointType_) );
230  }
231  }
232 
233  INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"Input parameters out of bounds");
234  }
235 
241  getHostBasis() const override {
243 
244  auto hostBasis = Teuchos::rcp(new HostBasis(order_x_, order_y_, pointType_));
245 
246  return hostBasis;
247  }
248  };
249 } // end namespace Intrepid2
250 
251 #endif /* Intrepid2_DerivedBasis_HGRAD_QUAD_h */
Implementation of bases that are tensor products of two or three component bases. ...
virtual HostBasisPtr< OutputValueType, PointValueType > getHostBasis() const override
Creates and returns a Basis object whose DeviceType template argument is Kokkos::HostSpace::device_ty...
Basis_Derived_HGRAD_QUAD(int polyOrder_x, int polyOrder_y, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
virtual void getValues(OutputViewType outputValues, const EOperator operatorType, const PointViewType inputPoints1, const PointViewType inputPoints2, bool tensorPoints) const override
multi-component getValues() method (required/called by TensorBasis)
For a multi-component tensor basis, specifies the operators to be applied to the components to produc...
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 const char * getName() const override
Returns basis name.
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...
virtual const char * getName() const override
Returns basis name.
Basis_Derived_HGRAD_QUAD(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT)
Constructor.
EPointType
Enumeration of types of point distributions in Intrepid.
virtual bool requireOrientation() const override
True if orientation is required.
virtual void getValues(BasisValues< OutputValueType, DeviceType > outputValues, const TensorPoints< PointValueType, DeviceType > inputPoints, const EOperator operatorType=OPERATOR_VALUE) const override
Evaluation of a FEM basis on a reference cell, using point and output value containers that allow pre...
Basis defined as the tensor product of two component bases.
Teuchos::RCP< BasisBase > getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override
returns the basis associated to a subCell.