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 
49 namespace 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
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::basisType_
EBasis basisType_
Type of the basis.
Definition: Intrepid_Basis.hpp:113
Intrepid::Basis::basisTagsAreSet_
bool basisTagsAreSet_
&quot;true&quot; if tagToOrdinal_ and ordinalToTag_ have been initialized
Definition: Intrepid_Basis.hpp:121
Intrepid::Basis::basisCoordinates_
ECoordinates basisCoordinates_
The coordinate system for which the basis is defined.
Definition: Intrepid_Basis.hpp:117
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::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::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::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
Intrepid::Basis_HCURL_HEX_In_FEM::initializeTags
void initializeTags()
Initializes tagToOrdinal_ and ordinalToTag_ lookup arrays.
Definition: Intrepid_HCURL_HEX_In_FEMDef.hpp:134
Generated by   doxygen 1.8.5