Nektar++
NodalTetElec.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File NodalTetElec.cpp
4 //
5 // For more information, please see: http://www.nektar.info
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a
14 // copy of this software and associated documentation files (the "Software"),
15 // to deal in the Software without restriction, including without limitation
16 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 // and/or sell copies of the Software, and to permit persons to whom the
18 // Software is furnished to do so, subject to the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be included
21 // in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 // DEALINGS IN THE SOFTWARE.
30 //
31 // Description: 3D Nodal Tet Electrostatic Point Definitions
32 //
33 ///////////////////////////////////////////////////////////////////////////////
34 
35 #include <LibUtilities/BasicUtils/ErrorUtil.hpp>
36 #include <LibUtilities/Foundations/NodalTetElec.h>
37 #include <LibUtilities/Foundations/NodalTetElecData.h>
38 #include <LibUtilities/Foundations/NodalUtil.h>
39 #include <LibUtilities/LinearAlgebra/NekVector.hpp>
40 #include <LibUtilities/LinearAlgebra/NekMatrix.hpp>
41 
42 namespace Nektar
43 {
44  namespace LibUtilities
45  {
46  bool NodalTetElec::initPointsManager[] = {
47  PointsManager().RegisterCreator(PointsKey(0, eNodalTetElec), NodalTetElec::Create)
48  };
49 
50  // ////////////////////////////////////////////////////////
51  // Coordinate the nodal tetrahedron electrostatic points
52 
53  void NodalTetElec::CalculatePoints()
54  {
55  // Allocate the storage for points
56  Points<NekDouble>::CalculatePoints();
57 
58  int index=0,isum=0;
59  const int offset = 5; //offset to match Datafile
60  NekDouble b,c,d;
61  unsigned int numPoints = GetNumPoints();
62 
63  // initialize values
64  for(unsigned int i=0; i < numPoints-2; ++i)
65  {
66  index += NodalTetElecNPTS[i];
67  }
68 
69  for(unsigned int i=0; i < NodalTetElecNPTS[numPoints-2]; ++i, ++index)
70  {
71  // 1 Point Symmetry: aaaa
72  if(int(NodalTetElecData[index][0]))
73  {
74  b = NodalTetElecData[index][6];
75  c = NodalTetElecData[index][7];
76  d = NodalTetElecData[index][8];
77 
78  m_points[0][isum] = 2.0*b - 1.0;
79  m_points[1][isum] = 2.0*c - 1.0;
80  m_points[2][isum] = 2.0*d - 1.0;
81  isum++;
82  continue;
83  }//end symmetry 1
84 
85 
86  // 4 Point symmetry: aaab or abbb
87  if(int(NodalTetElecData[index][1]))
88  {
89  for(unsigned int j=0; j < 4; ++j)
90  {
91  b = NodalTetElecData[index][offset + perm4_3d[j][1]];
92  c = NodalTetElecData[index][offset + perm4_3d[j][2]];
93  d = NodalTetElecData[index][offset + perm4_3d[j][3]];
94 
95  m_points[0][isum] = 2.0*b - 1.0;
96  m_points[1][isum] = 2.0*c - 1.0;
97  m_points[2][isum] = 2.0*d - 1.0;
98  isum++;
99  }//end j
100  continue;
101  }//end symmetry 4
102 
103 
104  // 6 Point symmetry: aabb
105  if(int(NodalTetElecData[index][2]))
106  {
107  for(unsigned int j=0; j < 6; ++j)
108  {
109  b = NodalTetElecData[index][offset + perm6_3d[j][1]];
110  c = NodalTetElecData[index][offset + perm6_3d[j][2]];
111  d = NodalTetElecData[index][offset + perm6_3d[j][3]];
112 
113  m_points[0][isum] = 2.0*b - 1.0;
114  m_points[1][isum] = 2.0*c - 1.0;
115  m_points[2][isum] = 2.0*d - 1.0;
116  isum++;
117  }//end j
118  continue;
119  }//end symmetry6
120 
121 
122  // 12 Point symmetry: case aabc
123  if(int(NodalTetElecData[index][3]) == 1)
124  {
125  for(unsigned int j=0; j < 12; ++j)
126  {
127  b = NodalTetElecData[index][offset + perm12A_3d[j][1]];
128  c = NodalTetElecData[index][offset + perm12A_3d[j][2]];
129  d = NodalTetElecData[index][offset + perm12A_3d[j][3]];
130 
131  m_points[0][isum] = 2.0*b - 1.0;
132  m_points[1][isum] = 2.0*c - 1.0;
133  m_points[2][isum] = 2.0*d - 1.0;
134  isum++;
135  }//end j
136  continue;
137  }//end symmetry 12 aabc
138 
139 
140  // 12 Point symmetry: case abcc
141  if(int(NodalTetElecData[index][3]) == 2)
142  {
143  for(unsigned int j=0; j < 12; ++j)
144  {
145  b = NodalTetElecData[index][offset + perm12B_3d[j][1]];
146  c = NodalTetElecData[index][offset + perm12B_3d[j][2]];
147  d = NodalTetElecData[index][offset + perm12B_3d[j][3]];
148 
149  m_points[0][isum] = 2.0*b - 1.0;
150  m_points[1][isum] = 2.0*c - 1.0;
151  m_points[2][isum] = 2.0*d - 1.0;
152  isum++;
153  }//end j
154  continue;
155  }//end symmetry 12 abcc
156 
157 
158  // 12 Point symmetry: case abbc
159  if(int(NodalTetElecData[index][3]) == 3)
160  {
161  for(unsigned int j=0; j < 12; ++j)
162  {
163  b = NodalTetElecData[index][offset + perm12C_3d[j][1]];
164  c = NodalTetElecData[index][offset + perm12C_3d[j][2]];
165  d = NodalTetElecData[index][offset + perm12C_3d[j][3]];
166 
167  m_points[0][isum] = 2.0*b - 1.0;
168  m_points[1][isum] = 2.0*c - 1.0;
169  m_points[2][isum] = 2.0*d - 1.0;
170  isum++;
171  }//end j
172  continue;
173  }//end symmetry 12 abbc
174 
175  // 24 Point symmetry: case abcd
176  if(int(NodalTetElecData[index][4]))
177  {
178  for(unsigned int j=0; j < 24; ++j)
179  {
180  b = NodalTetElecData[index][offset + perm24_3d[j][1]];
181  c = NodalTetElecData[index][offset + perm24_3d[j][2]];
182  d = NodalTetElecData[index][offset + perm24_3d[j][3]];
183 
184  m_points[0][isum] = 2.0*b - 1.0;
185  m_points[1][isum] = 2.0*c - 1.0;
186  m_points[2][isum] = 2.0*d - 1.0;
187  isum++;
188  }//end j
189  continue;
190  }//end symmetry24abcd
191 
192 
193  }//end npts
194 
195  NodalPointReorder3d();
196 
197  ASSERTL1((static_cast<unsigned int>(isum)==m_pointsKey.GetTotNumPoints()),"sum not equal to npts");
198 
199  m_util = MemoryManager<NodalUtilTetrahedron>::AllocateSharedPtr(
200  numPoints - 1, m_points[0], m_points[1], m_points[2]);
201  }
202 
203  void NodalTetElec::CalculateWeights()
204  {
205  // Allocate the storage for points
206  PointsBaseType::CalculateWeights();
207 
208  typedef DataType T;
209 
210  // Solve the Vandermonde system of integrals for the weight vector
211  NekVector<T> w = m_util->GetWeights();
212  m_weights = Array<OneD,T>( w.GetRows(), w.GetPtr() );
213  }
214 
215  // ////////////////////////////////////////
216  // CalculateInterpMatrix()
217  void NodalTetElec::CalculateInterpMatrix(const Array<OneD, const NekDouble>& xia, const Array<OneD, const NekDouble>& yia,
218  const Array<OneD, const NekDouble>& zia, Array<OneD, NekDouble>& interp)
219 
220  {
221  Array<OneD, Array<OneD, NekDouble> > xi(3);
222  xi[0] = xia;
223  xi[1] = yia;
224  xi[2] = zia;
225 
226  std::shared_ptr<NekMatrix<NekDouble> > mat =
227  m_util->GetInterpolationMatrix(xi);
228  Vmath::Vcopy(mat->GetRows() * mat->GetColumns(), mat->GetRawPtr(),
229  1, &interp[0], 1);
230  }
231 
232  void NodalTetElec::CalculateDerivMatrix()
233  {
234  // Allocate the derivative matrix.
235  PointsBaseType::CalculateDerivMatrix();
236 
237  m_derivmatrix[0] = m_util->GetDerivMatrix(0);
238  m_derivmatrix[1] = m_util->GetDerivMatrix(1);
239  m_derivmatrix[2] = m_util->GetDerivMatrix(2);
240  }
241 
242  std::shared_ptr<PointsBaseType> NodalTetElec::Create(const PointsKey &key)
243  {
244  std::shared_ptr<PointsBaseType> returnval(MemoryManager<NodalTetElec>::AllocateSharedPtr(key));
245  returnval->Initialize();
246  return returnval;
247  }
248 
249  void NodalTetElec::NodalPointReorder3d()
250  {
251  int cnt;
252  int istart,iend;
253 
254  const int nVerts = 4;
255  const int nEdgeInteriorPoints = GetNumPoints()-2;
256  const int nFaceInteriorPoints = (GetNumPoints()-3)*(GetNumPoints()-2)/2;
257  //const int nBoundaryPoints = 4 + 6*nEdgeInteriorPoints + 4*nFaceInteriorPoints;
258  const int nAllPoints = GetNumPoints()*(GetNumPoints()+1)*(GetNumPoints()+2)/6;
259  if(nEdgeInteriorPoints==0)
260  {
261  return;
262  }
263 
264  //group all edge 1 points
265  istart = nVerts;
266  for(int i = cnt = istart; i < nAllPoints; i++)
267  {
268  if( fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol &&
269  fabs(m_points[2][i] + 1.0) < NekConstants::kNekZeroTol)
270  {
271  std::swap(m_points[0][cnt], m_points[0][i]);
272  std::swap(m_points[1][cnt], m_points[1][i]);
273  std::swap(m_points[2][cnt], m_points[2][i]);
274  cnt++;
275  }
276  }
277 
278  // bubble sort edge 1 (counterclockwise numbering)
279  iend = istart + nEdgeInteriorPoints;
280  for(int i = istart; i < iend; i++)
281  {
282  for(int j = istart+1; j < iend; j++)
283  {
284  if(m_points[0][j] < m_points[0][j-1])
285  {
286  std::swap(m_points[0][j], m_points[0][j-1]);
287  std::swap(m_points[1][j], m_points[1][j-1]);
288  std::swap(m_points[2][j], m_points[2][j-1]);
289  }
290  }
291  }
292 
293  // group the points of edge 2 together;
294  istart = iend;
295  for(int i = cnt = istart; i < nAllPoints; i++)
296  {
297  if( fabs(m_points[1][i]+m_points[0][i]) < NekConstants::kNekZeroTol &&
298  fabs(m_points[2][i] + 1.0) < NekConstants::kNekZeroTol)
299  {
300  std::swap(m_points[0][cnt], m_points[0][i]);
301  std::swap(m_points[1][cnt], m_points[1][i]);
302  std::swap(m_points[2][cnt], m_points[2][i]);
303  cnt++;
304  }
305  }
306 
307  // bubble sort edge 2 (counterclockwise numbering)
308  iend = istart + nEdgeInteriorPoints;
309  for(int i = istart; i < iend; i++)
310  {
311  for(int j = istart+1; j < iend; j++)
312  {
313  if(m_points[1][j] < m_points[1][j-1])
314  {
315  std::swap(m_points[0][j], m_points[0][j-1]);
316  std::swap(m_points[1][j], m_points[1][j-1]);
317  std::swap(m_points[2][j], m_points[2][j-1]);
318  }
319  }
320  }
321 
322  // group the points of edge 3 together;
323  istart = iend;
324  for(int i = cnt = istart; i < nAllPoints; i++)
325  {
326  if( fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol &&
327  fabs(m_points[2][i] + 1.0) < NekConstants::kNekZeroTol)
328  {
329  std::swap(m_points[0][cnt], m_points[0][i]);
330  std::swap(m_points[1][cnt], m_points[1][i]);
331  std::swap(m_points[2][cnt], m_points[2][i]);
332  cnt++;
333  }
334  }
335 
336  // bubble sort edge 3 (counterclockwise numbering)
337  iend = istart + nEdgeInteriorPoints;
338  for(int i = istart; i < iend; i++)
339  {
340  for(int j = istart+1; j < iend; j++)
341  {
342  if(m_points[1][j] > m_points[1][j-1])
343  {
344  std::swap(m_points[0][j], m_points[0][j-1]);
345  std::swap(m_points[1][j], m_points[1][j-1]);
346  std::swap(m_points[2][j], m_points[2][j-1]);
347  }
348  }
349  }
350 
351  // group the points of edge 4 together;
352  istart = iend;
353  for(int i = cnt = istart; i < nAllPoints; i++)
354  {
355  if( fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol &&
356  fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
357  {
358  std::swap(m_points[0][cnt], m_points[0][i]);
359  std::swap(m_points[1][cnt], m_points[1][i]);
360  std::swap(m_points[2][cnt], m_points[2][i]);
361  cnt++;
362  }
363  }
364 
365  // bubble sort edge 3 (counterclockwise numbering)
366  iend = istart + nEdgeInteriorPoints;
367  for(int i = istart; i < iend; i++)
368  {
369  for(int j = istart+1; j < iend; j++)
370  {
371  if(m_points[2][j] < m_points[2][j-1])
372  {
373  std::swap(m_points[0][j], m_points[0][j-1]);
374  std::swap(m_points[1][j], m_points[1][j-1]);
375  std::swap(m_points[2][j], m_points[2][j-1]);
376  }
377  }
378  }
379 
380  // group the points of edge 5 together;
381  istart = iend;
382  for(int i = cnt = istart; i < nAllPoints; i++)
383  {
384  if( fabs(m_points[0][i]+m_points[2][i]) < NekConstants::kNekZeroTol &&
385  fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
386  {
387  std::swap(m_points[0][cnt], m_points[0][i]);
388  std::swap(m_points[1][cnt], m_points[1][i]);
389  std::swap(m_points[2][cnt], m_points[2][i]);
390  cnt++;
391  }
392  }
393 
394  // bubble sort edge 5 (counterclockwise numbering)
395  iend = istart + nEdgeInteriorPoints;
396  for(int i = istart; i < iend; i++)
397  {
398  for(int j = istart+1; j < iend; j++)
399  {
400  if(m_points[2][j] < m_points[2][j-1])
401  {
402  std::swap(m_points[0][j], m_points[0][j-1]);
403  std::swap(m_points[1][j], m_points[1][j-1]);
404  std::swap(m_points[2][j], m_points[2][j-1]);
405  }
406  }
407  }
408 
409  // group the points of edge 6 together;
410  istart = iend;
411  for(int i = cnt = istart; i < nAllPoints; i++)
412  {
413  if( fabs(m_points[1][i]+m_points[2][i]) < NekConstants::kNekZeroTol &&
414  fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol)
415  {
416  std::swap(m_points[0][cnt], m_points[0][i]);
417  std::swap(m_points[1][cnt], m_points[1][i]);
418  std::swap(m_points[2][cnt], m_points[2][i]);
419  cnt++;
420  }
421  }
422 
423  // bubble sort edge 6 (counterclockwise numbering)
424  iend = istart + nEdgeInteriorPoints;
425  for(int i = istart; i < iend; i++)
426  {
427  for(int j = istart+1; j < iend; j++)
428  {
429  if(m_points[2][j] < m_points[2][j-1])
430  {
431  std::swap(m_points[0][j], m_points[0][j-1]);
432  std::swap(m_points[1][j], m_points[1][j-1]);
433  std::swap(m_points[2][j], m_points[2][j-1]);
434  }
435  }
436  }
437 
438  if(GetNumPoints() < 4)
439  {
440  //no face points
441  return;
442  }
443 
444  // group the points of face 1 together;
445  istart = iend;
446  for(int i = cnt = istart; i < nAllPoints; i++)
447  {
448  if(fabs(m_points[2][i] + 1.0) < NekConstants::kNekZeroTol)
449  {
450  std::swap(m_points[0][cnt], m_points[0][i]);
451  std::swap(m_points[1][cnt], m_points[1][i]);
452  std::swap(m_points[2][cnt], m_points[2][i]);
453  cnt++;
454  }
455  }
456 
457  // bubble sort face1 (tensor numbering)
458  iend = istart + nFaceInteriorPoints;
459  bool repeat = true;
460  while(repeat)
461  {
462  repeat = false;
463  for(int i = istart; i < iend - 1; i++)
464  {
465  if(m_points[1][i] > m_points[1][i+1])
466  {
467  std::swap(m_points[0][i+1], m_points[0][i]);
468  std::swap(m_points[1][i+1], m_points[1][i]);
469  std::swap(m_points[2][i+1], m_points[2][i]);
470  repeat = true;
471  }
472  }
473  }
474  int offset = 0;
475  int npl = GetNumPoints() - 3;
476  while(npl > 1)
477  {
478  repeat = true;
479  while(repeat)
480  {
481  repeat = false;
482  for(int i = offset+istart; i < offset+istart + npl - 1; i++)
483  {
484  if(m_points[0][i] > m_points[0][i+1])
485  {
486  std::swap(m_points[0][i+1], m_points[0][i]);
487  std::swap(m_points[1][i+1], m_points[1][i]);
488  std::swap(m_points[2][i+1], m_points[2][i]);
489  repeat = true;
490  }
491  }
492  }
493  offset += npl;
494  npl--;
495  }
496 
497  // group the points of face 2 together;
498  istart = iend;
499  for(int i = cnt = istart; i < nAllPoints; i++)
500  {
501  if(fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
502  {
503  std::swap(m_points[0][cnt], m_points[0][i]);
504  std::swap(m_points[1][cnt], m_points[1][i]);
505  std::swap(m_points[2][cnt], m_points[2][i]);
506  cnt++;
507  }
508  }
509 
510  // bubble sort face2 (tensor numbering)
511  iend = istart + nFaceInteriorPoints;
512  repeat = true;
513  while(repeat)
514  {
515  repeat = false;
516  for(int i = istart; i < iend - 1; i++)
517  {
518  if(m_points[2][i] > m_points[2][i+1])
519  {
520  std::swap(m_points[0][i+1], m_points[0][i]);
521  std::swap(m_points[1][i+1], m_points[1][i]);
522  std::swap(m_points[2][i+1], m_points[2][i]);
523  repeat = true;
524  }
525  }
526  }
527  offset = 0;
528  npl = GetNumPoints() - 3;
529  while(npl > 1)
530  {
531  repeat = true;
532  while(repeat)
533  {
534  repeat = false;
535  for(int i = offset+istart; i < offset+istart + npl - 1; i++)
536  {
537  if(m_points[0][i] > m_points[0][i+1])
538  {
539  std::swap(m_points[0][i+1], m_points[0][i]);
540  std::swap(m_points[1][i+1], m_points[1][i]);
541  std::swap(m_points[2][i+1], m_points[2][i]);
542  repeat = true;
543  }
544  }
545  }
546  offset += npl;
547  npl--;
548  }
549 
550  // group the points of face 3 together;
551  istart = iend;
552  for(int i = cnt = istart; i < nAllPoints; i++)
553  {
554  if(fabs(m_points[1][i]+m_points[0][i]+m_points[2][i]+1.0) < 1E-9) //nek zero tol too small
555  {
556  std::swap(m_points[0][cnt], m_points[0][i]);
557  std::swap(m_points[1][cnt], m_points[1][i]);
558  std::swap(m_points[2][cnt], m_points[2][i]);
559  cnt++;
560  }
561  }
562 
563  // bubble sort face3 (tensor numbering)
564  iend = istart + nFaceInteriorPoints;
565  repeat = true;
566  while(repeat)
567  {
568  repeat = false;
569  for(int i = istart; i < iend - 1; i++)
570  {
571  if(m_points[2][i] > m_points[2][i+1])
572  {
573  std::swap(m_points[0][i+1], m_points[0][i]);
574  std::swap(m_points[1][i+1], m_points[1][i]);
575  std::swap(m_points[2][i+1], m_points[2][i]);
576  repeat = true;
577  }
578  }
579  }
580  offset = 0;
581  npl = GetNumPoints() - 3;
582  while(npl > 1)
583  {
584  repeat = true;
585  while(repeat)
586  {
587  repeat = false;
588  for(int i = offset+istart; i < offset+istart + npl - 1; i++)
589  {
590  if(m_points[1][i] > m_points[1][i+1])
591  {
592  std::swap(m_points[0][i+1], m_points[0][i]);
593  std::swap(m_points[1][i+1], m_points[1][i]);
594  std::swap(m_points[2][i+1], m_points[2][i]);
595  repeat = true;
596  }
597  }
598  }
599  offset += npl;
600  npl--;
601  }
602 
603  // group the points of face 4 together;
604  istart = iend;
605  for(int i = cnt = istart; i < nAllPoints; i++)
606  {
607  if(fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol)
608  {
609  std::swap(m_points[0][cnt], m_points[0][i]);
610  std::swap(m_points[1][cnt], m_points[1][i]);
611  std::swap(m_points[2][cnt], m_points[2][i]);
612  cnt++;
613  }
614  }
615 
616  // bubble sort face4 (tensor numbering)
617  iend = istart + nFaceInteriorPoints;
618  repeat = true;
619  while(repeat)
620  {
621  repeat = false;
622  for(int i = istart; i < iend - 1; i++)
623  {
624  if(m_points[2][i] > m_points[2][i+1])
625  {
626  std::swap(m_points[0][i+1], m_points[0][i]);
627  std::swap(m_points[1][i+1], m_points[1][i]);
628  std::swap(m_points[2][i+1], m_points[2][i]);
629  repeat = true;
630  }
631  }
632  }
633  offset = 0;
634  npl = GetNumPoints() - 3;
635  while(npl > 1)
636  {
637  repeat = true;
638  while(repeat)
639  {
640  repeat = false;
641  for(int i = offset+istart; i < offset+istart + npl - 1; i++)
642  {
643  if(m_points[1][i] > m_points[1][i+1])
644  {
645  std::swap(m_points[0][i+1], m_points[0][i]);
646  std::swap(m_points[1][i+1], m_points[1][i]);
647  std::swap(m_points[2][i+1], m_points[2][i]);
648  repeat = true;
649  }
650  }
651  }
652  offset += npl;
653  npl--;
654  }
655 
656  }
657 
658  } // end of namespace stdregion
659 } // end of namespace stdregion
660 
661 
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:250
Nektar::LibUtilities::NekManager::RegisterCreator
bool RegisterCreator(const KeyType &key, const CreateFuncType &createFunc)
Register the given function and associate it with the key. The return value is just to facilitate cal...
Definition: NekManager.hpp:166
Nektar::LibUtilities::NodalTetElec::Create
static std::shared_ptr< PointsBaseType > Create(const PointsKey &key)
Definition: NodalTetElec.cpp:242
Nektar::LibUtilities::NodalTetElec::CalculateInterpMatrix
void CalculateInterpMatrix(const Array< OneD, const NekDouble > &xia, const Array< OneD, const NekDouble > &yia, const Array< OneD, const NekDouble > &zia, Array< OneD, NekDouble > &interp)
Definition: NodalTetElec.cpp:217
Nektar::LibUtilities::NodalTetElec::m_util
std::shared_ptr< NodalUtilTetrahedron > m_util
Definition: NodalTetElec.h:95
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Storage for the point locations, allowing for up to a 3D points storage.
Definition: Points.h:390
Nektar::LibUtilities::Points< NekDouble >::m_derivmatrix
MatrixSharedPtrType m_derivmatrix[3]
Derivative matrices.
Definition: Points.h:396
Nektar::LibUtilities::Points< NekDouble >::m_pointsKey
PointsKey m_pointsKey
Points type for this points distributions.
Definition: Points.h:387
Nektar::LibUtilities::Points< NekDouble >::GetNumPoints
unsigned int GetNumPoints() const
Definition: Points.h:273
Nektar::LibUtilities::Points::CalculatePoints
virtual void CalculatePoints()
Definition: Points.h:400
Nektar::LibUtilities::Points< NekDouble >::m_weights
Array< OneD, DataType > m_weights
Quadrature weights for the weights.
Definition: Points.h:392
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition: Points.h:60
Nektar::LibUtilities::PointsKey::GetTotNumPoints
unsigned int GetTotNumPoints() const
Definition: Points.h:180
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition: NekMemoryManager.hpp:84
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:171
Nektar::NekVector::GetPtr
Array< OneD, DataType > & GetPtr()
Definition: NekVector.cpp:227
Nektar::NekVector::GetRows
unsigned int GetRows() const
Definition: NekVector.cpp:215
Nektar::LibUtilities::perm6_3d
static const unsigned int perm6_3d[6][4]
Definition: NodalTetElecData.h:7
Nektar::LibUtilities::perm12B_3d
static const unsigned int perm12B_3d[12][4]
Definition: NodalTetElecData.h:11
Nektar::LibUtilities::perm12C_3d
static const unsigned int perm12C_3d[12][4]
Definition: NodalTetElecData.h:13
Nektar::LibUtilities::perm12A_3d
static const unsigned int perm12A_3d[12][4]
Definition: NodalTetElecData.h:9
Nektar::LibUtilities::PointsManager
PointsManagerT & PointsManager(void)
Definition: ManagerAccess.cpp:42
Nektar::LibUtilities::NodalTetElecNPTS
static const unsigned int NodalTetElecNPTS[NodalTetElecAvailable]
Definition: NodalTetElecData.h:24
Nektar::LibUtilities::NodalTetElecData
static const NekDouble NodalTetElecData[][9]
Definition: NodalTetElecData.h:25
Nektar::LibUtilities::perm24_3d
static const unsigned int perm24_3d[24][4]
Definition: NodalTetElecData.h:16
Nektar::LibUtilities::perm4_3d
static const unsigned int perm4_3d[4][4]
Definition: NodalTetElecData.h:6
Nektar::LibUtilities::eNodalTetElec
@ eNodalTetElec
3D Nodal Electrostatic Points on a Tetrahedron
Definition: PointsType.h:73
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:51
Nektar
The above copyright notice and this permission notice shall be included.
Definition: CoupledSolver.h:1
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1199
Generated on Wed Nov 24 2021 10:33:28 for Nektar++ by doxygen 1.9.1