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>
52  Basis_HDIV_HEX_In_FEM<Scalar,ArrayScalar>::Basis_HDIV_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() * 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>
136  void Basis_HDIV_HEX_In_FEM<Scalar, ArrayScalar>::initializeTags() {
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>
270  void Basis_HDIV_HEX_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
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>
473  void Basis_HDIV_HEX_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar& outputValues,
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>
482  void Basis_HDIV_HEX_In_FEM<Scalar,ArrayScalar>::getDofCoords(ArrayScalar & DofCoords) const
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
Intrepid::Basis::basisType_
EBasis basisType_
Type of the basis.
Definition: Intrepid_Basis.hpp:113
Intrepid::Basis_HDIV_HEX_In_FEM::Basis_HDIV_HEX_In_FEM
Basis_HDIV_HEX_In_FEM(int order, const ArrayScalar &ptsClosed, const ArrayScalar &ptsOpen)
Constructor.
Definition: Intrepid_HDIV_HEX_In_FEMDef.hpp:52
Intrepid::Basis::basisTagsAreSet_
bool basisTagsAreSet_
&quot;true&quot; if tagToOrdinal_ and ordinalToTag_ have been initialized
Definition: Intrepid_Basis.hpp:121
Intrepid::Basis_HDIV_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_HDIV_HEX_In_FEMDef.hpp:482
Intrepid::Basis::basisCoordinates_
ECoordinates basisCoordinates_
The coordinate system for which the basis is defined.
Definition: Intrepid_Basis.hpp:117
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::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
Intrepid::Basis_HDIV_HEX_In_FEM::initializeTags
void initializeTags()
Initializes tagToOrdinal_ and ordinalToTag_ lookup arrays.
Definition: Intrepid_HDIV_HEX_In_FEMDef.hpp:136
Intrepid::Basis_HDIV_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_HDIV_HEX_In_FEMDef.hpp:270
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::basisCardinality_
int basisCardinality_
Cardinality of the basis, i.e., the number of basis functions/degrees-of-freedom. ...
Definition: Intrepid_Basis.hpp:100
Generated by   doxygen 1.8.5