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
49namespace 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>
83 Basis_HDIV_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HDIV_HEX_In_FEM( int order , const EPointType &pointType ):
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
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.
void getValues(ArrayScalar &outputValues, const ArrayScalar &inputPoints, const EOperator operatorType) const
Evaluation of a FEM basis on a reference Hexahedral cell.
virtual void getDofCoords(ArrayScalar &DofCoords) const
Returns spatial locations (coordinates) of degrees of freedom on a reference cell; defined for interp...
void initializeTags()
Initializes tagToOrdinal_ and ordinalToTag_ lookup arrays.
Basis_HDIV_HEX_In_FEM(int order, const ArrayScalar &ptsClosed, const ArrayScalar &ptsOpen)
Constructor.
bool basisTagsAreSet_
"true" if tagToOrdinal_ and ordinalToTag_ have been initialized
int basisCardinality_
Cardinality of the basis, i.e., the number of basis functions/degrees-of-freedom.
ECoordinates basisCoordinates_
The coordinate system for which the basis is defined.
EBasis basisType_
Type of the basis.
int basisDegree_
Degree of the largest complete polynomial space that can be represented by the basis.
shards::CellTopology basisCellTopology_
Base topology of the cells for which the basis is defined. See the Shards package http://trilinos....
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)