Intrepid
Intrepid_HCURL_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
48
49namespace Intrepid {
50
51 template<class Scalar, class ArrayScalar>
52 Basis_HCURL_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HCURL_HEX_In_FEM( int order ,
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()
62 * closedBasis_.getCardinality() * openBasis_.getCardinality();
63 this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
64 this -> basisType_ = BASIS_FEM_FIAT;
65 this -> basisCoordinates_ = COORDINATES_CARTESIAN;
66 this -> basisTagsAreSet_ = false;
67
68 Array<Array<RCP<Basis<Scalar,ArrayScalar > > > > bases(3);
69 bases[0].resize(3); bases[1].resize(3); bases[2].resize(3);
70 bases[0][0] = rcp( &openBasis_ , false );
71 bases[0][1] = rcp( &closedBasis_ , false );
72 bases[0][2] = rcp( &closedBasis_ , false );
73 bases[1][0] = rcp( &closedBasis_ , false );
74 bases[1][1] = rcp( &openBasis_ , false );
75 bases[1][2] = rcp( &closedBasis_ , false );
76 bases[2][0] = rcp( &closedBasis_ , false );
77 bases[2][1] = rcp( &closedBasis_ , false );
78 bases[2][2] = rcp( &openBasis_ , false );
79 this->setBases( bases );
80
81 }
82
83 template<class Scalar, class ArrayScalar>
84 Basis_HCURL_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HCURL_HEX_In_FEM( int order , const EPointType &pointType ):
85 closedBasis_( order , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL:POINTTYPE_EQUISPACED ),
86 openBasis_( order-1 , pointType==POINTTYPE_SPECTRAL?POINTTYPE_SPECTRAL_OPEN:POINTTYPE_EQUISPACED ),
87 closedPts_( order+1 , 1 ),
88 openPts_( order , 1 )
89 {
90 this -> basisDegree_ = order;
91 this -> basisCardinality_ = 3 * closedBasis_.getCardinality()
92 * closedBasis_.getCardinality() * openBasis_.getCardinality();
93 this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() );
94 this -> basisType_ = BASIS_FEM_FIAT;
95 this -> basisCoordinates_ = COORDINATES_CARTESIAN;
96 this -> basisTagsAreSet_ = false;
97
98 PointTools::getLattice<Scalar,FieldContainer<Scalar> >( closedPts_ ,
99 shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
100 order ,
101 0 ,
102 pointType==POINTTYPE_SPECTRAL?POINTTYPE_WARPBLEND:POINTTYPE_EQUISPACED );
103
104 if (pointType == POINTTYPE_SPECTRAL)
105 {
106 PointTools::getGaussPoints<Scalar,FieldContainer<Scalar> >( openPts_ ,
107 order - 1 );
108 }
109 else
110 {
111 PointTools::getLattice<Scalar,FieldContainer<Scalar> >( openPts_ ,
112 shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >()) ,
113 order - 1,
114 0 ,
115 POINTTYPE_EQUISPACED );
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( &openBasis_ , false );
121 bases[0][1] = rcp( &closedBasis_ , false );
122 bases[0][2] = rcp( &closedBasis_ , false );
123 bases[1][0] = rcp( &closedBasis_ , false );
124 bases[1][1] = rcp( &openBasis_ , false );
125 bases[1][2] = rcp( &closedBasis_ , false );
126 bases[2][0] = rcp( &closedBasis_ , false );
127 bases[2][1] = rcp( &closedBasis_ , false );
128 bases[2][2] = rcp( &openBasis_ , false );
129 this->setBases( bases );
130
131 }
132
133 template<class Scalar, class ArrayScalar>
134 void Basis_HCURL_HEX_In_FEM<Scalar, ArrayScalar>::initializeTags() {
135
136 // Basis-dependent intializations
137 int tagSize = 4; // size of DoF tag
138 int posScDim = 0; // position in the tag, counting from 0, of the subcell dim
139 int posScOrd = 1; // position in the tag, counting from 0, of the subcell ordinal
140 int posDfOrd = 2; // position in the tag, counting from 0, of DoF ordinal relative to the subcell
141
142 std::vector<int> tags( tagSize * this->getCardinality() );
143
144 const std::vector<std::vector<int> >& closedDofTags = closedBasis_.getAllDofTags();
145 const std::vector<std::vector<int> >& openDofTags = openBasis_.getAllDofTags();
146
147 std::map<int,std::map<int,int> > total_dof_per_entity;
148 std::map<int,std::map<int,int> > current_dof_per_entity;
149
150 const int order = this->basisDegree_;
151
152 // 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 // 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 // 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
171 // edge dof
172 for (int i=0;i<12;i++) {
173 total_dof_per_entity[1][i] = order;
174 }
175 // face dof
176 for (int i=0;i<6;i++) {
177 total_dof_per_entity[2][i] = 2 * (order - 1) * order;
178 }
179 // internal dof
180 total_dof_per_entity[3][0] = this->basisCardinality_ - 12 * order - 6 * total_dof_per_entity[2][0];
181
182 int tagcur = 0;
183 for (int k=0;k<closedBasis_.getCardinality();k++) {
184 const int dimk = closedDofTags[k][0];
185 const int entk = closedDofTags[k][1];
186 for (int j=0;j<closedBasis_.getCardinality();j++) {
187 const int dimj = closedDofTags[j][0];
188 const int entj = closedDofTags[j][1];
189 for (int i=0;i<openBasis_.getCardinality();i++) {
190 const int dimi = openDofTags[i][0];
191 const int enti = openDofTags[i][1];
192 int dofdim;
193 int dofent;
194 ProductTopology::lineProduct3d(dimi,enti,dimj,entj,dimk,entk,dofdim,dofent);
195 tags[4*tagcur] = dofdim;
196 tags[4*tagcur+1] = dofent;
197 tags[4*tagcur+2] = current_dof_per_entity[dofdim][dofent];
198 tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
199 current_dof_per_entity[dofdim][dofent]++;
200 tagcur++;
201 }
202 }
203 }
204 for (int k=0;k<closedBasis_.getCardinality();k++) {
205 const int dimk = closedDofTags[k][0];
206 const int entk = closedDofTags[k][1];
207 for (int j=0;j<openBasis_.getCardinality();j++) {
208 const int dimj = openDofTags[j][0];
209 const int entj = openDofTags[j][1];
210 for (int i=0;i<closedBasis_.getCardinality();i++) {
211 const int dimi = closedDofTags[i][0];
212 const int enti = closedDofTags[i][1];
213 int dofdim;
214 int dofent;
215 ProductTopology::lineProduct3d(dimi,enti,dimj,entj,dimk,entk,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 tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
220 current_dof_per_entity[dofdim][dofent]++;
221 tagcur++;
222 }
223 }
224 }
225 for (int k=0;k<openBasis_.getCardinality();k++) {
226 const int dimk = openDofTags[k][0];
227 const int entk = openDofTags[k][1];
228 for (int j=0;j<closedBasis_.getCardinality();j++) {
229 const int dimj = closedDofTags[j][0];
230 const int entj = closedDofTags[j][1];
231 for (int i=0;i<closedBasis_.getCardinality();i++) {
232 const int dimi = closedDofTags[i][0];
233 const int enti = closedDofTags[i][1];
234 int dofdim;
235 int dofent;
236 ProductTopology::lineProduct3d(dimi,enti,dimj,entj,dimk,entk,dofdim,dofent);
237 tags[4*tagcur] = dofdim;
238 tags[4*tagcur+1] = dofent;
239 tags[4*tagcur+2] = current_dof_per_entity[dofdim][dofent];
240 tags[4*tagcur+3] = total_dof_per_entity[dofdim][dofent];
241 current_dof_per_entity[dofdim][dofent]++;
242 tagcur++;
243 }
244 }
245 }
246
247 // Basis-independent function sets tag and enum data in tagToOrdinal_ and ordinalToTag_ arrays:
248 Intrepid::setOrdinalTagData(this -> tagToOrdinal_,
249 this -> ordinalToTag_,
250 &(tags[0]),
251 this -> basisCardinality_,
252 tagSize,
253 posScDim,
254 posScOrd,
255 posDfOrd);
256 }
257
258
259 template<class Scalar, class ArrayScalar>
260 void Basis_HCURL_HEX_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
261 const ArrayScalar & inputPoints,
262 const EOperator operatorType) const {
263
264 // Verify arguments
265#ifdef HAVE_INTREPID_DEBUG
266 Intrepid::getValues_HCURL_Args<Scalar, ArrayScalar>(outputValues,
267 inputPoints,
268 operatorType,
269 this -> getBaseCellTopology(),
270 this -> getCardinality() );
271#endif
272
273 // Number of evaluation points = dim 0 of inputPoints
274 int dim0 = inputPoints.dimension(0);
275
276 // separate out points
277 FieldContainer<Scalar> xPoints(dim0,1);
278 FieldContainer<Scalar> yPoints(dim0,1);
279 FieldContainer<Scalar> zPoints(dim0,1);
280
281 for (int i=0;i<dim0;i++) {
282 xPoints(i,0) = inputPoints(i,0);
283 yPoints(i,0) = inputPoints(i,1);
284 zPoints(i,0) = inputPoints(i,2);
285 }
286
287 switch (operatorType) {
288 case OPERATOR_VALUE:
289 {
290 FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
291 FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
292 FieldContainer<Scalar> closedBasisValsZPts( closedBasis_.getCardinality() , dim0 );
293 FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
294 FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
295 FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
296
297 closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
298 closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
299 closedBasis_.getValues( closedBasisValsZPts , zPoints , OPERATOR_VALUE );
300 openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
301 openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
302 openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
303
304 // first we get the "horizontal basis functions that are tangent to the x-varying edges
305 int bfcur = 0;
306 for (int k=0;k<closedBasis_.getCardinality();k++) {
307 for (int j=0;j<closedBasis_.getCardinality();j++) {
308 for (int i=0;i<openBasis_.getCardinality();i++) {
309 for (int l=0;l<dim0;l++) {
310 outputValues(bfcur,l,0) = openBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
311 outputValues(bfcur,l,1) = 0.0;
312 outputValues(bfcur,l,2) = 0.0;
313 }
314 bfcur++;
315 }
316 }
317 }
318
319 // second we get the basis functions in the direction of the y-varying edges
320 for (int k=0;k<closedBasis_.getCardinality();k++) {
321 for (int j=0;j<openBasis_.getCardinality();j++) {
322 for (int i=0;i<closedBasis_.getCardinality();i++) {
323 for (int l=0;l<dim0;l++) {
324 outputValues(bfcur,l,0) = 0.0;
325 outputValues(bfcur,l,1) = closedBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
326 outputValues(bfcur,l,2) = 0.0;
327 }
328 bfcur++;
329 }
330 }
331 }
332
333 // third we get the basis functions in the direction of the y-varying edges
334 for (int k=0;k<openBasis_.getCardinality();k++) {
335 for (int j=0;j<closedBasis_.getCardinality();j++) {
336 for (int i=0;i<closedBasis_.getCardinality();i++) {
337 for (int l=0;l<dim0;l++) {
338 outputValues(bfcur,l,0) = 0.0;
339 outputValues(bfcur,l,1) = 0.0;
340 outputValues(bfcur,l,2) = closedBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * openBasisValsZPts(k,l);
341 }
342 bfcur++;
343 }
344 }
345 }
346 }
347 break;
348 case OPERATOR_CURL:
349 {
350 FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
351 FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
352 FieldContainer<Scalar> closedBasisValsZPts( closedBasis_.getCardinality() , dim0 );
353 FieldContainer<Scalar> closedBasisDerivsXPts( closedBasis_.getCardinality() , dim0 , 1 );
354 FieldContainer<Scalar> closedBasisDerivsYPts( closedBasis_.getCardinality() , dim0 , 1 );
355 FieldContainer<Scalar> closedBasisDerivsZPts( closedBasis_.getCardinality() , dim0 , 1 );
356 FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
357 FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
358 FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
359
360 closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
361 closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
362 closedBasis_.getValues( closedBasisValsZPts , zPoints , OPERATOR_VALUE );
363 closedBasis_.getValues( closedBasisDerivsXPts , xPoints , OPERATOR_D1 );
364 closedBasis_.getValues( closedBasisDerivsYPts , yPoints , OPERATOR_D1 );
365 closedBasis_.getValues( closedBasisDerivsZPts , zPoints , OPERATOR_D1 );
366 openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
367 openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
368 openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
369
370 int bfcur = 0;
371
372 // first we get the basis functions that are tangent to the x-varying edges
373 for (int k=0;k<closedBasis_.getCardinality();k++) {
374 for (int j=0;j<closedBasis_.getCardinality();j++) {
375 for (int i=0;i<openBasis_.getCardinality();i++) {
376 for (int l=0;l<dim0;l++) {
377 outputValues(bfcur,l,0) = 0.0;
378 outputValues(bfcur,l,1) = openBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * closedBasisDerivsZPts(k,l,0);
379 outputValues(bfcur,l,2) = -openBasisValsXPts(i,l) * closedBasisDerivsYPts(j,l,0) * closedBasisValsZPts(k,l);
380 }
381 bfcur++;
382 }
383 }
384 }
385
386 // second we get the basis functions in the direction of the y-varying edges
387 for (int k=0;k<closedBasis_.getCardinality();k++) {
388 for (int j=0;j<openBasis_.getCardinality();j++) {
389 for (int i=0;i<closedBasis_.getCardinality();i++) {
390 for (int l=0;l<dim0;l++) {
391 outputValues(bfcur,l,0) = -closedBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisDerivsZPts(k,l,0);
392 outputValues(bfcur,l,1) = 0.0;
393 outputValues(bfcur,l,2) = closedBasisDerivsXPts(i,l,0) * openBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
394 }
395 bfcur++;
396 }
397 }
398 }
399
400 // third we get the basis functions in the direction of the y-varying edges
401 for (int k=0;k<openBasis_.getCardinality();k++) {
402 for (int j=0;j<closedBasis_.getCardinality();j++) {
403 for (int i=0;i<closedBasis_.getCardinality();i++) {
404 for (int l=0;l<dim0;l++) {
405 outputValues(bfcur,l,0) = closedBasisValsXPts(i,l) * closedBasisDerivsYPts(j,l,0) * openBasisValsZPts(k,l);
406 outputValues(bfcur,l,1) = -closedBasisDerivsXPts(i,l,0) * closedBasisValsYPts(j,l) * openBasisValsZPts(k,l);
407 outputValues(bfcur,l,2) = 0.0;
408 }
409 bfcur++;
410 }
411 }
412 }
413 }
414 break;
415 case OPERATOR_DIV:
416 TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument,
417 ">>> ERROR (Basis_HCURL_HEX_In_FEM): DIV is invalid operator for HCURL Basis Functions");
418 break;
419
420 case OPERATOR_GRAD:
421 TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
422 ">>> ERROR (Basis_HCURL_HEX_In_FEM): GRAD is invalid operator for HCURL Basis Functions");
423 break;
424
425 case OPERATOR_D1:
426 case OPERATOR_D2:
427 case OPERATOR_D3:
428 case OPERATOR_D4:
429 case OPERATOR_D5:
430 case OPERATOR_D6:
431 case OPERATOR_D7:
432 case OPERATOR_D8:
433 case OPERATOR_D9:
434 case OPERATOR_D10:
435 TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1) ||
436 (operatorType == OPERATOR_D2) ||
437 (operatorType == OPERATOR_D3) ||
438 (operatorType == OPERATOR_D4) ||
439 (operatorType == OPERATOR_D5) ||
440 (operatorType == OPERATOR_D6) ||
441 (operatorType == OPERATOR_D7) ||
442 (operatorType == OPERATOR_D8) ||
443 (operatorType == OPERATOR_D9) ||
444 (operatorType == OPERATOR_D10) ),
445 std::invalid_argument,
446 ">>> ERROR (Basis_HCURL_HEX_In_FEM): Invalid operator type");
447 break;
448
449 default:
450 TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
451 (operatorType != OPERATOR_GRAD) &&
452 (operatorType != OPERATOR_CURL) &&
453 (operatorType != OPERATOR_CURL) &&
454 (operatorType != OPERATOR_D1) &&
455 (operatorType != OPERATOR_D2) &&
456 (operatorType != OPERATOR_D3) &&
457 (operatorType != OPERATOR_D4) &&
458 (operatorType != OPERATOR_D5) &&
459 (operatorType != OPERATOR_D6) &&
460 (operatorType != OPERATOR_D7) &&
461 (operatorType != OPERATOR_D8) &&
462 (operatorType != OPERATOR_D9) &&
463 (operatorType != OPERATOR_D10) ),
464 std::invalid_argument,
465 ">>> ERROR (Basis_HCURL_HEX_In_FEM): Invalid operator type");
466 }
467 }
468
469
470
471 template<class Scalar, class ArrayScalar>
472 void Basis_HCURL_HEX_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar& outputValues,
473 const ArrayScalar & inputPoints,
474 const ArrayScalar & cellVertices,
475 const EOperator operatorType) const {
476 TEUCHOS_TEST_FOR_EXCEPTION( (true), std::logic_error,
477 ">>> ERROR (Basis_HCURL_HEX_In_FEM): FEM Basis calling an FVD member function");
478 }
479
480 template<class Scalar, class ArrayScalar>
481 void Basis_HCURL_HEX_In_FEM<Scalar,ArrayScalar>::getDofCoords(ArrayScalar & DofCoords) const
482 {
483 // x-component basis functions
484 int cur = 0;
485
486 for (int k=0;k<closedPts_.dimension(0);k++)
487 {
488 for (int j=0;j<closedPts_.dimension(0);j++)
489 {
490 for (int i=0;i<openPts_.dimension(0);i++)
491 {
492 DofCoords(cur,0) = openPts_(i,0);
493 DofCoords(cur,1) = closedPts_(j,0);
494 DofCoords(cur,2) = closedPts_(k,0);
495 cur++;
496 }
497 }
498 }
499 // y-component basis functions
500 for (int k=0;k<closedPts_.dimension(0);k++)
501 {
502 for (int j=0;j<openPts_.dimension(0);j++)
503 {
504 for (int i=0;i<closedPts_.dimension(0);i++)
505 {
506 DofCoords(cur,0) = closedPts_(i,0);
507 DofCoords(cur,1) = openPts_(j,0);
508 DofCoords(cur,2) = closedPts_(k,0);
509 cur++;
510 }
511 }
512 }
513
514 // z-component basis functions
515 for (int k=0;k<openPts_.dimension(0);k++)
516 {
517 for (int j=0;j<closedPts_.dimension(0);j++)
518 {
519 for (int i=0;i<closedPts_.dimension(0);i++)
520 {
521 DofCoords(cur,0) = closedPts_(i,0);
522 DofCoords(cur,1) = closedPts_(j,0);
523 DofCoords(cur,2) = openPts_(k,0);
524 cur++;
525 }
526 }
527 }
528
529 return;
530 }
531
532}// namespace Intrepid
533
534#if defined(Intrepid_SHOW_DEPRECATED_WARNINGS)
535#ifdef __GNUC__
536#warning "The Intrepid package is deprecated"
537#endif
538#endif
539
Intrepid::getValues_HCURL_Args
void getValues_HCURL_Args(ArrayScalar &outputValues, const ArrayScalar &inputPoints, const EOperator operatorType, const shards::CellTopology &cellTopo, const int basisCard)
Runtime check of the arguments for the getValues method in an HCURL-conforming FEM basis....
Definition Intrepid_Basis.hpp:257
Intrepid::setOrdinalTagData
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.
Definition Intrepid_Utils.cpp:455
Intrepid::Basis_HCURL_HEX_In_FEM::getDofCoords
virtual void getDofCoords(ArrayScalar &DofCoords) const
Returns spatial locations (coordinates) of degrees of freedom on a reference cell; defined for interp...
Definition Intrepid_HCURL_HEX_In_FEMDef.hpp:481
Intrepid::Basis_HCURL_HEX_In_FEM::Basis_HCURL_HEX_In_FEM
Basis_HCURL_HEX_In_FEM(int order, const ArrayScalar &ptsClosed, const ArrayScalar &ptsOpen)
Constructor.
Definition Intrepid_HCURL_HEX_In_FEMDef.hpp:52
Intrepid::Basis_HCURL_HEX_In_FEM::getValues
void getValues(ArrayScalar &outputValues, const ArrayScalar &inputPoints, const EOperator operatorType) const
Evaluation of a FEM basis on a reference Hexahedral cell.
Definition Intrepid_HCURL_HEX_In_FEMDef.hpp:260
Intrepid::Basis_HCURL_HEX_In_FEM::initializeTags
void initializeTags()
Initializes tagToOrdinal_ and ordinalToTag_ lookup arrays.
Definition Intrepid_HCURL_HEX_In_FEMDef.hpp:134
Intrepid::Basis
An abstract base class that defines interface for concrete basis implementations for Finite Element (...
Definition Intrepid_Basis.hpp:89
Intrepid::Basis::basisTagsAreSet_
bool basisTagsAreSet_
"true" if tagToOrdinal_ and ordinalToTag_ have been initialized
Definition Intrepid_Basis.hpp:121
Intrepid::Basis::getBaseCellTopology
virtual const shards::CellTopology getBaseCellTopology() const
Returns the base cell topology for which the basis is defined. See Shards documentation http://trilin...
Definition Intrepid_Basis.hpp:113
Intrepid::Basis::tagToOrdinal_
std::vector< std::vector< std::vector< int > > > tagToOrdinal_
DoF tag to ordinal lookup table.
Definition Intrepid_Basis.hpp:147
Intrepid::Basis::basisCardinality_
int basisCardinality_
Cardinality of the basis, i.e., the number of basis functions/degrees-of-freedom.
Definition Intrepid_Basis.hpp:100
Intrepid::Basis::basisCoordinates_
ECoordinates basisCoordinates_
The coordinate system for which the basis is defined.
Definition Intrepid_Basis.hpp:117
Intrepid::Basis::basisType_
EBasis basisType_
Type of the basis.
Definition Intrepid_Basis.hpp:113
Intrepid::Basis::basisDegree_
int basisDegree_
Degree of the largest complete polynomial space that can be represented by the basis.
Definition Intrepid_Basis.hpp:104
Intrepid::Basis::ordinalToTag_
std::vector< std::vector< int > > ordinalToTag_
DoF ordinal to tag lookup table.
Definition Intrepid_Basis.hpp:134
Intrepid::Basis::basisCellTopology_
shards::CellTopology basisCellTopology_
Base topology of the cells for which the basis is defined. See the Shards package http://trilinos....
Definition Intrepid_Basis.hpp:109
Intrepid::Basis::getCardinality
virtual int getCardinality() const
Returns cardinality of the basis.
Definition Intrepid_Basis.hpp:101
Intrepid::FieldContainer
Implementation of a templated lexicographical container for a multi-indexed scalar quantity....
Definition Intrepid_FieldContainer.hpp:78
Intrepid::PointTools::getLattice
static void getLattice(ArrayType &pts, const shards::CellTopology &cellType, const int order, const int 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...
Definition Intrepid_PointToolsDef.hpp:52
Intrepid::PointTools::getGaussPoints
static void getGaussPoints(ArrayType &pts, const int order)
Definition Intrepid_PointToolsDef.hpp:75
Intrepid::ProductTopology::lineProduct3d
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)
Definition Intrepid_ProductTopology.hpp:173
Generated by doxygen 1.15.0