Intrepid2
Intrepid2_HGRAD_TRI_Cn_FEMDef.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), or
38 // Mauro Perego (mperego@sandia.gov)
39 //
40 // ************************************************************************
41 // @HEADER
42 
49 #ifndef __INTREPID2_HGRAD_TRI_CN_FEM_DEF_HPP__
50 #define __INTREPID2_HGRAD_TRI_CN_FEM_DEF_HPP__
51 
53 
54 namespace Intrepid2 {
55 
56 // -------------------------------------------------------------------------------------
57 namespace Impl {
58 
59 template<EOperator opType>
60 template<typename outputViewType,
61 typename inputViewType,
62 typename workViewType,
63 typename vinvViewType>
64 KOKKOS_INLINE_FUNCTION
65 void
66 Basis_HGRAD_TRI_Cn_FEM::Serial<opType>::
67 getValues( outputViewType output,
68  const inputViewType input,
69  workViewType work,
70  const vinvViewType vinv ) {
71 
72  constexpr ordinal_type spaceDim = 2;
73  const ordinal_type
74  card = vinv.extent(0),
75  npts = input.extent(0);
76 
77  // compute order
78  ordinal_type order = 0;
79  for (ordinal_type p=0;p<=Parameters::MaxOrder;++p) {
80  if (card == Intrepid2::getPnCardinality<spaceDim>(p) ) {
81  order = p;
82  break;
83  }
84  }
85 
86  typedef typename Kokkos::DynRankView<typename workViewType::value_type, typename workViewType::memory_space> viewType;
87  auto vcprop = Kokkos::common_view_alloc_prop(work);
88  auto ptr = work.data();
89 
90  switch (opType) {
91  case OPERATOR_VALUE: {
92  const viewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts);
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  output.access(i,j) = 0.0;
101  for (ordinal_type k=0;k<card;++k)
102  output.access(i,j) += vinv(k,i)*phis.access(k,j);
103  }
104  break;
105  }
106  case OPERATOR_GRAD:
107  case OPERATOR_D1: {
108  const viewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim);
109  ptr += card*npts*spaceDim*get_dimension_scalar(work);
110  const viewType workView(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim+1);
111  Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
112  Serial<opType>::getValues(phis, input, workView, order);
113 
114  for (ordinal_type i=0;i<card;++i)
115  for (ordinal_type j=0;j<npts;++j)
116  for (ordinal_type k=0;k<spaceDim;++k) {
117  output.access(i,j,k) = 0.0;
118  for (ordinal_type l=0;l<card;++l)
119  output.access(i,j,k) += vinv(l,i)*phis.access(l,j,k);
120  }
121  break;
122  }
123  case OPERATOR_D2:
124  case OPERATOR_D3:
125  case OPERATOR_D4:
126  case OPERATOR_D5:
127  case OPERATOR_D6:
128  case OPERATOR_D7:
129  case OPERATOR_D8:
130  case OPERATOR_D9:
131  case OPERATOR_D10: {
132  const ordinal_type dkcard = getDkCardinality<opType,spaceDim>(); //(orDn + 1);
133  const viewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, dkcard);
134  viewType dummyView;
135 
136  Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
137  Serial<opType>::getValues(phis, input, dummyView, order);
138 
139  for (ordinal_type i=0;i<card;++i)
140  for (ordinal_type j=0;j<npts;++j)
141  for (ordinal_type k=0;k<dkcard;++k) {
142  output.access(i,j,k) = 0.0;
143  for (ordinal_type l=0;l<card;++l)
144  output.access(i,j,k) += vinv(l,i)*phis.access(l,j,k);
145  }
146  break;
147  }
148  case OPERATOR_CURL: { // only works in 2d. first component is -d/dy, second is d/dx
149  const viewType phis(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim);
150  ptr += card*npts*spaceDim*get_dimension_scalar(work);
151  const viewType workView(Kokkos::view_wrap(ptr, vcprop), card, npts, spaceDim+1);
152 
153 
154  Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::
155  Serial<OPERATOR_D1>::getValues(phis, input, workView, order);
156 
157  for (ordinal_type i=0;i<card;++i)
158  for (ordinal_type j=0;j<npts;++j) {
159  output.access(i,j,0) = 0.0;
160  for (ordinal_type l=0;l<card;++l)
161  output.access(i,j,0) += vinv(l,i)*phis.access(l,j,1);
162  output.access(i,j,1) = 0.0;
163  for (ordinal_type l=0;l<card;++l)
164  output.access(i,j,1) -= vinv(l,i)*phis.access(l,j,0);
165  }
166  break;
167  }
168  default: {
169  INTREPID2_TEST_FOR_ABORT( true,
170  ">>> ERROR (Basis_HGRAD_TRI_Cn_FEM): Operator type not implemented");
171  }
172  }
173 }
174 
175 template<typename SpT, ordinal_type numPtsPerEval,
176 typename outputValueValueType, class ...outputValueProperties,
177 typename inputPointValueType, class ...inputPointProperties,
178 typename vinvValueType, class ...vinvProperties>
179 void
180 Basis_HGRAD_TRI_Cn_FEM::
181 getValues( Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValues,
182  const Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPoints,
183  const Kokkos::DynRankView<vinvValueType, vinvProperties...> vinv,
184  const EOperator operatorType) {
185  typedef Kokkos::DynRankView<outputValueValueType,outputValueProperties...> outputValueViewType;
186  typedef Kokkos::DynRankView<inputPointValueType, inputPointProperties...> inputPointViewType;
187  typedef Kokkos::DynRankView<vinvValueType, vinvProperties...> vinvViewType;
188  typedef typename ExecSpace<typename inputPointViewType::execution_space,SpT>::ExecSpaceType ExecSpaceType;
189 
190  // loopSize corresponds to cardinality
191  const auto loopSizeTmp1 = (inputPoints.extent(0)/numPtsPerEval);
192  const auto loopSizeTmp2 = (inputPoints.extent(0)%numPtsPerEval != 0);
193  const auto loopSize = loopSizeTmp1 + loopSizeTmp2;
194  Kokkos::RangePolicy<ExecSpaceType,Kokkos::Schedule<Kokkos::Static> > policy(0, loopSize);
195 
196  typedef typename inputPointViewType::value_type inputPointType;
197 
198  const ordinal_type cardinality = outputValues.extent(0);
199  const ordinal_type spaceDim = 2;
200 
201  auto vcprop = Kokkos::common_view_alloc_prop(inputPoints);
202  typedef typename Kokkos::DynRankView< inputPointType, typename inputPointViewType::memory_space> workViewType;
203 
204  switch (operatorType) {
205  case OPERATOR_VALUE: {
206  workViewType work(Kokkos::view_alloc("Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality, inputPoints.extent(0));
207  typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
208  OPERATOR_VALUE,numPtsPerEval> FunctorType;
209  Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
210  break;
211  }
212  case OPERATOR_GRAD:
213  case OPERATOR_D1: {
214  workViewType work(Kokkos::view_alloc("Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*(2*spaceDim+1), inputPoints.extent(0));
215  typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
216  OPERATOR_D1,numPtsPerEval> FunctorType;
217  Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
218  break;
219  }
220  case OPERATOR_CURL: {
221  workViewType work(Kokkos::view_alloc("Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*(2*spaceDim+1), inputPoints.extent(0));
222  typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
223  OPERATOR_CURL,numPtsPerEval> FunctorType;
224  Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
225  break;
226  }
227  case OPERATOR_D2: {
228  typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType,
229  OPERATOR_D2,numPtsPerEval> FunctorType;
230  workViewType work(Kokkos::view_alloc("Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality*outputValues.extent(2), inputPoints.extent(0));
231  Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
232  break;
233  }
234  /* case OPERATOR_D3: {
235  typedef Functor<outputValueViewType,inputPointViewType,vinvViewType, workViewType
236  OPERATOR_D3,numPtsPerEval> FunctorType;
237  workViewType work(Kokkos::view_alloc("Basis_HGRAD_TRI_Cn_FEM::getValues::work", vcprop), cardinality, inputPoints.extent(0), outputValues.extent(2));
238  Kokkos::parallel_for( policy, FunctorType(outputValues, inputPoints, vinv, work) );
239  break;
240  }*/
241  default: {
242  INTREPID2_TEST_FOR_EXCEPTION( true , std::invalid_argument,
243  ">>> ERROR (Basis_HGRAD_TRI_Cn_FEM): Operator type not implemented" );
244  }
245  }
246 }
247 }
248 
249 // -------------------------------------------------------------------------------------
250 template<typename SpT, typename OT, typename PT>
252 Basis_HGRAD_TRI_Cn_FEM( const ordinal_type order,
253  const EPointType pointType ) {
254  constexpr ordinal_type spaceDim = 2;
255 
256  this->basisCardinality_ = Intrepid2::getPnCardinality<spaceDim>(order); // bigN
257  this->basisDegree_ = order; // small n
258  this->basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() );
259  this->basisType_ = BASIS_FEM_FIAT;
260  this->basisCoordinates_ = COORDINATES_CARTESIAN;
261 
262  const ordinal_type card = this->basisCardinality_;
263 
264  // points are computed in the host and will be copied
265  Kokkos::DynRankView<scalarType,typename SpT::array_layout,Kokkos::HostSpace>
266  dofCoords("Hgrad::Tri::Cn::dofCoords", card, spaceDim);
267 
268  // construct lattice
269  const ordinal_type offset = 0;
270  PointTools::getLattice( dofCoords,
271  this->basisCellTopology_,
272  order, offset,
273  pointType );
274 
275  this->dofCoords_ = Kokkos::create_mirror_view(typename SpT::memory_space(), dofCoords);
276  Kokkos::deep_copy(this->dofCoords_, dofCoords);
277 
278  // form Vandermonde matrix. Actually, this is the transpose of the VDM,
279  // so we transpose on copy below.
280  const ordinal_type lwork = card*card;
281  Kokkos::DynRankView<scalarType,Kokkos::LayoutLeft,Kokkos::HostSpace>
282  vmat("Hgrad::Tri::Cn::vmat", card, card),
283  work("Hgrad::Tri::Cn::work", lwork),
284  ipiv("Hgrad::Tri::Cn::ipiv", card);
285 
286  Impl::Basis_HGRAD_TRI_Cn_FEM_ORTH::getValues<Kokkos::HostSpace::execution_space,Parameters::MaxNumPtsPerBasisEval>(vmat, dofCoords, order, OPERATOR_VALUE);
287 
288  ordinal_type info = 0;
289  Teuchos::LAPACK<ordinal_type,scalarType> lapack;
290 
291  lapack.GETRF(card, card,
292  vmat.data(), vmat.stride_1(),
293  (ordinal_type*)ipiv.data(),
294  &info);
295 
296  INTREPID2_TEST_FOR_EXCEPTION( info != 0,
297  std::runtime_error ,
298  ">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM) lapack.GETRF returns nonzero info." );
299 
300  lapack.GETRI(card,
301  vmat.data(), vmat.stride_1(),
302  (ordinal_type*)ipiv.data(),
303  work.data(), lwork,
304  &info);
305 
306  INTREPID2_TEST_FOR_EXCEPTION( info != 0,
307  std::runtime_error ,
308  ">>> ERROR: (Intrepid2::Basis_HGRAD_TRI_Cn_FEM) lapack.GETRI returns nonzero info." );
309 
310  // create host mirror
311  Kokkos::DynRankView<scalarType,typename SpT::array_layout,Kokkos::HostSpace>
312  vinv("Hgrad::Line::Cn::vinv", card, card);
313 
314  for (ordinal_type i=0;i<card;++i)
315  for (ordinal_type j=0;j<card;++j)
316  vinv(i,j) = vmat(j,i);
317 
318  this->vinv_ = Kokkos::create_mirror_view(typename SpT::memory_space(), vinv);
319  Kokkos::deep_copy(this->vinv_ , vinv);
320 
321  // initialize tags
322  {
323  // Basis-dependent initializations
324  constexpr ordinal_type tagSize = 4; // size of DoF tag, i.e., number of fields in the tag
325  const ordinal_type posScDim = 0; // position in the tag, counting from 0, of the subcell dim
326  const ordinal_type posScOrd = 1; // position in the tag, counting from 0, of the subcell ordinal
327  const ordinal_type posDfOrd = 2; // position in the tag, counting from 0, of DoF ordinal relative to the subcell
328 
329  constexpr ordinal_type maxCard = Intrepid2::getPnCardinality<spaceDim, Parameters::MaxOrder>();
330  ordinal_type tags[maxCard][tagSize];
331 
332  const ordinal_type
333  numEdgeDof = Intrepid2::getPnCardinality<1>(order-2),
334  numElemDof = (order > 2 ? Intrepid2::getPnCardinality<2>(order-3) : 0);
335 
336  scalarType xi0, xi1, xi2;
337  const scalarType eps = threshold();
338 
339  ordinal_type edgeId[3] = {}, elemId = 0;
340  for (ordinal_type i=0;i<card;++i) {
341 
342  // compute barycentric coordinates
343  const auto x = dofCoords(i,0);
344  const auto y = dofCoords(i,1);
345  xi0 = 1.0 - x - y;
346  xi1= x;
347  xi2= y;
348 
349  // vertex
350  if ((1.0 - xi0) < eps) { // vert 0
351  tags[i][0] = 0; // vertex dof
352  tags[i][1] = 0; // vertex id
353  tags[i][2] = 0; // local dof id
354  tags[i][3] = 1; // total vert dof
355  }
356  else if ((1.0 - xi1) < eps) { // vert 1
357  tags[i][0] = 0; // vertex dof
358  tags[i][1] = 1; // vertex id
359  tags[i][2] = 0; // local dof id
360  tags[i][3] = 1; // total vert dof
361  }
362  else if ((1.0 - xi2) < eps) { // vert 2
363  tags[i][0] = 0; // vertex dof
364  tags[i][1] = 2; // vertex id
365  tags[i][2] = 0; // local dof id
366  tags[i][3] = 1; // total vert dof
367  }
368  else if (xi2 < eps) { // edge 0
369  tags[i][0] = 1; // edge dof
370  tags[i][1] = 0; // edge id
371  tags[i][2] = edgeId[0]++; // local dof id
372  tags[i][3] = numEdgeDof; // total vert dof
373  }
374  else if (xi0 < eps) { // edge 1
375  tags[i][0] = 1; // edge dof
376  tags[i][1] = 1; // edge id
377  tags[i][2] = edgeId[1]++; // local dof id
378  tags[i][3] = numEdgeDof; // total vert dof
379  }
380  else if (xi1 < eps) { // edge 2
381  tags[i][0] = 1; // edge dof
382  tags[i][1] = 2; // edge id
383  tags[i][2] = edgeId[2]++; // local dof id
384  tags[i][3] = numEdgeDof; // total vert dof
385  }
386  else { // elem
387  tags[i][0] = 2; // intr dof
388  tags[i][1] = 0; // intr id
389  tags[i][2] = elemId++; // local dof id
390  tags[i][3] = numElemDof; // total vert dof
391  }
392  }
393 
394  ordinal_type_array_1d_host tagView(&tags[0][0], card*tagSize);
395 
396  // Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
397  // tags are constructed on host
398  this->setOrdinalTagData(this->tagToOrdinal_,
399  this->ordinalToTag_,
400  tagView,
401  this->basisCardinality_,
402  tagSize,
403  posScDim,
404  posScOrd,
405  posDfOrd);
406  }
407 }
408 } // namespace Intrepid2
409 #endif
Header file for the Intrepid2::Basis_HGRAD_TRI_Cn_FEM_ORTH class.
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 (currently disabled for other ce...
Kokkos::View< ordinal_type *,typename ExecSpaceType::array_layout, Kokkos::HostSpace > ordinal_type_array_1d_host
View type for 1d host array.
Basis_HGRAD_TRI_Cn_FEM(const ordinal_type order, const EPointType pointType=POINTTYPE_EQUISPACED)
Constructor.
static constexpr ordinal_type MaxOrder
The maximum reconstruction order.