Intrepid
Intrepid_HDIV_HEX_In_FEMDef.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ************************************************************************
3 //
4 // Intrepid 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 Pavel Bochev (pbboche@sandia.gov)
38 // Denis Ridzal (dridzal@sandia.gov), or
39 // Kara Peterson (kjpeter@sandia.gov)
40 //
41 // ************************************************************************
42 // @HEADER
43 
49 namespace Intrepid {
50 
51  template<class Scalar, class ArrayScalar>
53  const ArrayScalar & ptsClosed ,
54  const ArrayScalar & ptsOpen):
55  closedBasis_( order , ptsClosed ),
56  openBasis_( order-1 , ptsOpen ),
57  closedPts_( ptsClosed ),
58  openPts_( ptsOpen )
59  {
60  this -> basisDegree_ = order;
61  this -> basisCardinality_ = 3 * closedBasis_.getCardinality() * openBasis_.getCardinality() * openBasis_.getCardinality();
62  this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
63  this -> basisType_ = BASIS_FEM_FIAT;
64  this -> basisCoordinates_ = COORDINATES_CARTESIAN;
65  this -> basisTagsAreSet_ = false;
66 
67  Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(3);
68  bases[0].resize(3); bases[1].resize(3); bases[2].resize(3);
69  bases[0][0] = rcp( &closedBasis_ , false );
70  bases[0][1] = rcp( &openBasis_ , false );
71  bases[0][2] = rcp( &openBasis_ , false );
72  bases[1][0] = rcp( &openBasis_ , false );
73  bases[1][1] = rcp( &closedBasis_ , false );
74  bases[1][2] = rcp( &openBasis_ , false );
75  bases[2][0] = rcp( &openBasis_ , false );
76  bases[2][1] = rcp( &openBasis_ , false );
77  bases[2][2] = rcp( &closedBasis_ , false );
78  this->setBases( bases );
79 
80  }
81 
82  template<class Scalar, class ArrayScalar>
84  closedBasis_( order , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL:POINTTYPE_EQUISPACED ),
85  openBasis_( order-1 , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL_OPEN:POINTTYPE_EQUISPACED ),
86  closedPts_( order+1 , 1 ),
87  openPts_( order , 1 )
88  {
89  this -> basisDegree_ = order;
90  this -> basisCardinality_ = 3 * closedBasis_.getCardinality() * openBasis_.getCardinality() * openBasis_.getCardinality();
91  this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
92  this -> basisType_ = BASIS_FEM_FIAT;
93  this -> basisCoordinates_ = COORDINATES_CARTESIAN;
94  this -> basisTagsAreSet_ = false;
95 
96  PointTools::getLattice<Scalar,FieldContainer<Scalar> >( closedPts_ ,
97  shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
98  order ,
99  0 ,
100  pointType==POINTTYPE_SPECTRAL?POINTTYPE_WARPBLEND:POINTTYPE_EQUISPACED );
101 
102  if (pointType == POINTTYPE_SPECTRAL)
103  {
104  PointTools::getGaussPoints<Scalar,FieldContainer<Scalar> >( openPts_ ,
105  order - 1 );
106  }
107  else
108  {
109  PointTools::getLattice<Scalar,FieldContainer<Scalar> >( openPts_ ,
110  shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
111  order - 1,
112  0 ,
113  POINTTYPE_EQUISPACED );
114 
115  }
116 
117 
118  Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(3);
119  bases[0].resize(3); bases[1].resize(3); bases[2].resize(3);
120  bases[0][0] = rcp( &closedBasis_ , false );
121  bases[0][1] = rcp( &openBasis_ , false );
122  bases[0][2] = rcp( &openBasis_ , false );
123  bases[1][0] = rcp( &openBasis_ , false );
124  bases[1][1] = rcp( &closedBasis_ , false );
125  bases[1][2] = rcp( &openBasis_ , false );
126  bases[2][0] = rcp( &openBasis_ , false );
127  bases[2][1] = rcp( &openBasis_ , false );
128  bases[2][2] = rcp( &closedBasis_ , false );
129  this->setBases( bases );
130 
131  }
132 
133 
134 
135  template<class Scalar, class ArrayScalar>
137 
138  // Basis-dependent intializations
139  int tagSize = 4; // size of DoF tag
140  int posScDim = 0; // position in the tag, counting from 0, of the subcell dim
141  int posScOrd = 1; // position in the tag, counting from 0, of the subcell ordinal
142  int posDfOrd = 2; // position in the tag, counting from 0, of DoF ordinal relative to the subcell
143 
144  std::vector<int> tags( tagSize * this->getCardinality() );
145 
146  const std::vector<std::vector<int> >& closedDofTags = closedBasis_.getAllDofTags();
147  const std::vector<std::vector<int> >& openDofTags = openBasis_.getAllDofTags();
148 
149  std::map<int,std::map<int,int> > total_dof_per_entity;
150  std::map<int,std::map<int,int> > current_dof_per_entity;
151 
152  // four vertices
153  for (int i=0;i<4;i++) {
154  total_dof_per_entity[0][i] = 0;
155  current_dof_per_entity[0][i] = 0;
156  }
157  // twelve edges
158  for (int i=0;i<12;i++) {
159  total_dof_per_entity[1][i] = 0;
160  current_dof_per_entity[1][i] = 0;
161  }
162  // six faces
163  for (int i=0;i<6;i++) {
164  total_dof_per_entity[2][i] = 0;
165  current_dof_per_entity[2][i] = 0;
166  }
167  total_dof_per_entity[3][0] = 0;
168  current_dof_per_entity[3][0] = 0;
169 
170  // tally dof on each facet. none on vertex or edge
171  for (int i=0;i<6;i++) {
172  total_dof_per_entity[2][i] = openBasis_.getCardinality() * openBasis_.getCardinality();
173  }
174 
175  total_dof_per_entity[2][0] = this->getCardinality() - 6 * openBasis_.getCardinality()* openBasis_.getCardinality();
176 
177  int tagcur = 0;
178  // loop over the x-component basis functions, which are (psi(x)phi(y)phi(z),0,0)
179  // for psi in the closed basis and phi in the open
180  for (int k=0;k<openBasis_.getCardinality();k++) {
181  const int odimk = openDofTags[k][0];
182  const int oentk = openDofTags[k][1];
183  for (int j=0;j<openBasis_.getCardinality();j++) {
184  const int odimj = openDofTags[j][0];
185  const int oentj = openDofTags[j][1];
186  for (int i=0;i<closedBasis_.getCardinality();i++) {
187  const int cdim = closedDofTags[i][0];
188  const int cent = closedDofTags[i][1];
189  int dofdim;
190  int dofent;
191  ProductTopology::lineProduct3d(cdim,cent,odimj,oentj,odimk,oentk,dofdim,dofent);
192  tags[4*tagcur] = dofdim;
193  tags[4*tagcur+1] = dofent;
194  tags[4*tagcur+2] = current_dof_per_entity[dofdim][dofent];
195  current_dof_per_entity[dofdim][dofent]++;
196  tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
197  tagcur++;
198  }
199  }
200  }
201 
202  // now we have to do it for the y-component basis functions, which are
203  // (0,phi(x)psi(y)phi(z),0) for psi in the closed basis and phi in the open
204  for (int k=0;k<openBasis_.getCardinality();k++) {
205  const int odimk = openDofTags[k][0];
206  const int oentk = openDofTags[k][1];
207  for (int j=0;j<closedBasis_.getCardinality();j++) {
208  const int cdim = closedDofTags[j][0];
209  const int cent = closedDofTags[j][1];
210  for (int i=0;i<openBasis_.getCardinality();i++) {
211  const int odimi = openDofTags[i][0];
212  const int oenti = openDofTags[i][1];
213  int dofdim;
214  int dofent;
215  ProductTopology::lineProduct3d(odimi,oenti,cdim,cent,odimk,oentk,dofdim,dofent);
216  tags[4*tagcur] = dofdim;
217  tags[4*tagcur+1] = dofent;
218  tags[4*tagcur+2] = current_dof_per_entity[dofdim][dofent];
219  current_dof_per_entity[dofdim][dofent]++;
220  tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
221  tagcur++;
222  }
223  }
224  }
225 
226  // now we have to do it for the z-component basis functions, which are
227  // (0,0,phi(x)phi(y)psi(z)) for psi in the closed basis and phi in the open
228  for (int k=0;k<closedBasis_.getCardinality();k++) {
229  const int cdim = closedDofTags[k][0];
230  const int cent = closedDofTags[k][1];
231  for (int j=0;j<openBasis_.getCardinality();j++) {
232  const int odimj = openDofTags[j][0];
233  const int oentj = openDofTags[j][1];
234  for (int i=0;i<openBasis_.getCardinality();i++) {
235  const int odimi = openDofTags[i][0];
236  const int oenti = openDofTags[i][1];
237  int dofdim;
238  int dofent;
239  ProductTopology::lineProduct3d(odimi,oenti,odimj,oentj,cdim,cent,dofdim,dofent);
240  tags[4*tagcur] = dofdim;
241  tags[4*tagcur+1] = dofent;
242  tags[4*tagcur+2] = current_dof_per_entity[dofdim][dofent];
243  current_dof_per_entity[dofdim][dofent]++;
244  tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
245  tagcur++;
246  }
247  }
248  }
249 
250 // for (int i=0;i<this->getCardinality();i++) {
251 // for (int j=0;j<4;j++) {
252 // std::cout << tags[4*i+j] << " ";
253 // }
254 // std::cout << std::endl;
255 // }
256 
257  // Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
258  Intrepid::setOrdinalTagData(this -> tagToOrdinal_,
259  this -> ordinalToTag_,
260  &(tags[0]),
261  this -> basisCardinality_,
262  tagSize,
263  posScDim,
264  posScOrd,
265  posDfOrd);
266  }
267 
268 
269  template<class Scalar, class ArrayScalar>
271  const ArrayScalar & inputPoints,
272  const EOperator operatorType) const {
273 
274  // Verify arguments
275 #ifdef HAVE_INTREPID_DEBUG
276  Intrepid::getValues_HDIV_Args<Scalar, ArrayScalar>(outputValues,
277  inputPoints,
278  operatorType,
279  this -> getBaseCellTopology(),
280  this -> getCardinality() );
281 #endif
282 
283  // Number of evaluation points = dim 0 of inputPoints
284  int dim0 = inputPoints.dimension(0);
285 
286  // separate out points
287  FieldContainer<Scalar> xPoints(dim0,1);
288  FieldContainer<Scalar> yPoints(dim0,1);
289  FieldContainer<Scalar> zPoints(dim0,1);
290 
291 
292  for (int i=0;i<dim0;i++) {
293  xPoints(i,0) = inputPoints(i,0);
294  yPoints(i,0) = inputPoints(i,1);
295  zPoints(i,0) = inputPoints(i,2);
296  }
297 
298  switch (operatorType) {
299  case OPERATOR_VALUE:
300  {
301  FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
302  FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
303  FieldContainer<Scalar> closedBasisValsZPts( closedBasis_.getCardinality() , dim0 );
304  FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
305  FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
306  FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
307 
308  closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
309  closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
310  closedBasis_.getValues( closedBasisValsZPts , zPoints , OPERATOR_VALUE );
311  openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
312  openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
313  openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
314 
315  int bfcur = 0;
316  // x component bfs are (closed(x) open(y) open(z),0,0)
317  for (int k=0;k<openBasis_.getCardinality();k++) {
318  for (int j=0;j<openBasis_.getCardinality();j++) {
319  for (int i=0;i<closedBasis_.getCardinality();i++) {
320  for (int l=0;l<dim0;l++) {
321  outputValues(bfcur,l,0) = closedBasisValsXPts(i,l) * openBasisValsYPts(j,l) * openBasisValsZPts(k,l);
322  outputValues(bfcur,l,1) = 0.0;
323  outputValues(bfcur,l,2) = 0.0;
324  }
325  bfcur++;
326  }
327  }
328  }
329 
330  // y component bfs are (0,open(x) closed(y) open(z),0)
331  for (int k=0;k<openBasis_.getCardinality();k++) {
332  for (int j=0;j<closedBasis_.getCardinality();j++) {
333  for (int i=0;i<openBasis_.getCardinality();i++) {
334  for (int l=0;l<dim0;l++) {
335  outputValues(bfcur,l,0) = 0.0;
336  outputValues(bfcur,l,1) = openBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * openBasisValsZPts(k,l);
337  outputValues(bfcur,l,2) = 0.0;
338  }
339  bfcur++;
340  }
341  }
342  }
343 
344  // z component bfs are (0,0,open(x) open(y) closed(z))
345  for (int k=0;k<closedBasis_.getCardinality();k++) {
346  for (int j=0;j<openBasis_.getCardinality();j++) {
347  for (int i=0;i<openBasis_.getCardinality();i++) {
348  for (int l=0;l<dim0;l++) {
349  outputValues(bfcur,l,0) = 0.0;
350  outputValues(bfcur,l,1) = 0.0;
351  outputValues(bfcur,l,2) = openBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
352  }
353  bfcur++;
354  }
355  }
356  }
357 
358 
359  }
360  break;
361  case OPERATOR_DIV:
362  {
363  FieldContainer<Scalar> closedBasisDerivsXPts( closedBasis_.getCardinality() , dim0 , 1 );
364  FieldContainer<Scalar> closedBasisDerivsYPts( closedBasis_.getCardinality() , dim0 , 1 );
365  FieldContainer<Scalar> closedBasisDerivsZPts( closedBasis_.getCardinality() , dim0 , 1 );
366  FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
367  FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
368  FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
369 
370  closedBasis_.getValues( closedBasisDerivsXPts , xPoints , OPERATOR_D1 );
371  closedBasis_.getValues( closedBasisDerivsYPts , yPoints , OPERATOR_D1 );
372  closedBasis_.getValues( closedBasisDerivsZPts , zPoints , OPERATOR_D1 );
373  openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
374  openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
375  openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
376 
377  int bfcur = 0;
378 
379  // x component basis functions first
380  for (int k=0;k<openBasis_.getCardinality();k++) {
381  for (int j=0;j<openBasis_.getCardinality();j++) {
382  for (int i=0;i<closedBasis_.getCardinality();i++) {
383  for (int l=0;l<dim0;l++) {
384  outputValues(bfcur,l) = closedBasisDerivsXPts(i,l,0) * openBasisValsYPts(j,l) * openBasisValsZPts(k,l);
385  }
386  bfcur++;
387  }
388  }
389  }
390 
391  // now y component basis functions
392  for (int k=0;k<openBasis_.getCardinality();k++) {
393  for (int j=0;j<closedBasis_.getCardinality();j++) {
394  for (int i=0;i<openBasis_.getCardinality();i++) {
395  for (int l=0;l<dim0;l++) {
396  outputValues(bfcur,l) = openBasisValsXPts(i,l) * closedBasisDerivsYPts(j,l,0) * openBasisValsZPts(k,l);
397  }
398  bfcur++;
399  }
400  }
401  }
402 
403  // now z component basis functions
404  for (int k=0;k<closedBasis_.getCardinality();k++) {
405  for (int j=0;j<openBasis_.getCardinality();j++) {
406  for (int i=0;i<openBasis_.getCardinality();i++) {
407  for (int l=0;l<dim0;l++) {
408  outputValues(bfcur,l) = openBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisDerivsZPts(k,l,0);
409  }
410  bfcur++;
411  }
412  }
413  }
414  }
415  break;
416  case OPERATOR_CURL:
417  TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_CURL), std::invalid_argument,
418  ">>> ERROR (Basis_HDIV_HEX_In_FEM): CURL is invalid operator for HDIV Basis Functions");
419  break;
420 
421  case OPERATOR_GRAD:
422  TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
423  ">>> ERROR (Basis_HDIV_HEX_In_FEM): GRAD is invalid operator for HDIV Basis Functions");
424  break;
425 
426  case OPERATOR_D1:
427  case OPERATOR_D2:
428  case OPERATOR_D3:
429  case OPERATOR_D4:
430  case OPERATOR_D5:
431  case OPERATOR_D6:
432  case OPERATOR_D7:
433  case OPERATOR_D8:
434  case OPERATOR_D9:
435  case OPERATOR_D10:
436  TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1) ||
437  (operatorType == OPERATOR_D2) ||
438  (operatorType == OPERATOR_D3) ||
439  (operatorType == OPERATOR_D4) ||
440  (operatorType == OPERATOR_D5) ||
441  (operatorType == OPERATOR_D6) ||
442  (operatorType == OPERATOR_D7) ||
443  (operatorType == OPERATOR_D8) ||
444  (operatorType == OPERATOR_D9) ||
445  (operatorType == OPERATOR_D10) ),
446  std::invalid_argument,
447  ">>> ERROR (Basis_HDIV_HEX_In_FEM): Invalid operator type");
448  break;
449 
450  default:
451  TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
452  (operatorType != OPERATOR_GRAD) &&
453  (operatorType != OPERATOR_CURL) &&
454  (operatorType != OPERATOR_DIV) &&
455  (operatorType != OPERATOR_D1) &&
456  (operatorType != OPERATOR_D2) &&
457  (operatorType != OPERATOR_D3) &&
458  (operatorType != OPERATOR_D4) &&
459  (operatorType != OPERATOR_D5) &&
460  (operatorType != OPERATOR_D6) &&
461  (operatorType != OPERATOR_D7) &&
462  (operatorType != OPERATOR_D8) &&
463  (operatorType != OPERATOR_D9) &&
464  (operatorType != OPERATOR_D10) ),
465  std::invalid_argument,
466  ">>> ERROR (Basis_HDIV_HEX_In_FEM): Invalid operator type");
467  }
468  }
469 
470 
471 
472  template<class Scalar, class ArrayScalar>
474  const ArrayScalar & inputPoints,
475  const ArrayScalar & cellVertices,
476  const EOperator operatorType) const {
477  TEUCHOS_TEST_FOR_EXCEPTION( (true), std::logic_error,
478  ">>> ERROR (Basis_HDIV_HEX_In_FEM): FEM Basis calling an FVD member function");
479  }
480 
481  template<class Scalar, class ArrayScalar>
483  {
484  // x-component basis functions
485  int cur = 0;
486 
487  for (int k=0;k<openPts_.dimension(0);k++)
488  {
489  for (int j=0;j<openPts_.dimension(0);j++)
490  {
491  for (int i=0;i<closedPts_.dimension(0);i++)
492  {
493  DofCoords(cur,0) = closedPts_(i,0);
494  DofCoords(cur,1) = openPts_(j,0);
495  DofCoords(cur,2) = openPts_(k,0);
496  cur++;
497  }
498  }
499  }
500 
501  // y-component basis functions
502  for (int k=0;k<openPts_.dimension(0);k++)
503  {
504  for (int j=0;j<closedPts_.dimension(0);j++)
505  {
506  for (int i=0;i<openPts_.dimension(0);i++)
507  {
508  DofCoords(cur,0) = openPts_(i,0);
509  DofCoords(cur,1) = closedPts_(j,0);
510  DofCoords(cur,2) = openPts_(k,0);
511  cur++;
512  }
513  }
514  }
515 
516  // z-component basis functions
517  for (int k=0;k<closedPts_.dimension(0);k++)
518  {
519  for (int j=0;j<openPts_.dimension(0);j++)
520  {
521  for (int i=0;i<openPts_.dimension(0);i++)
522  {
523  DofCoords(cur,0) = openPts_(i,0);
524  DofCoords(cur,1) = openPts_(j,0);
525  DofCoords(cur,2) = closedPts_(k,0);
526  cur++;
527  }
528  }
529  }
530 
531 
532 
533  return;
534  }
535 
536 }// namespace Intrepid
virtual void getDofCoords(ArrayScalar &DofCoords) const
Returns spatial locations (coordinates) of degrees of freedom on a reference cell; defined for interp...
EBasis basisType_
Type of the basis.
void setOrdinalTagData(std::vector< std::vector< std::vector< int > > > &tagToOrdinal, std::vector< std::vector< int > > &ordinalToTag, const int *tags, const int basisCard, const int tagSize, const int posScDim, const int posScOrd, const int posDfOrd)
Fills ordinalToTag_ and tagToOrdinal_ by basis-specific tag data.
Basis_HDIV_HEX_In_FEM(int order, const ArrayScalar &ptsClosed, const ArrayScalar &ptsOpen)
Constructor.
bool basisTagsAreSet_
"true" if tagToOrdinal_ and ordinalToTag_ have been initialized
EOperator
Enumeration of primitive operators available in Intrepid. Primitive operators act on reconstructed fu...
ECoordinates basisCoordinates_
The coordinate system for which the basis is defined.
shards::CellTopology basisCellTopology_
Base topology of the cells for which the basis is defined. See the Shards package http://trilinos...
void getValues(ArrayScalar &outputValues, const ArrayScalar &inputPoints, const EOperator operatorType) const
Evaluation of a FEM basis on a reference Hexahedral cell.
EPointType
Enumeration of types of point distributions in Intrepid.
static void lineProduct3d(const int dim0, const int entity0, const int dim1, const int entity1, const int dim2, const int entity2, int &resultdim, int &resultentity)
void initializeTags()
Initializes tagToOrdinal_ and ordinalToTag_ lookup arrays.
int basisDegree_
Degree of the largest complete polynomial space that can be represented by the basis.
int basisCardinality_
Cardinality of the basis, i.e., the number of basis functions/degrees-of-freedom. ...