Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
NodalTriFekete.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File NodalTriFekete.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 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: 2D Nodal Triangle Fekete Point Definitions
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
45 
46 
47 namespace Nektar
48 {
49  namespace LibUtilities
50  {
51 
52 
53  // ////////////////////////////////////////////////////////
54  // Coordinate the nodal trianlge Fekete points
56  {
57  // Allocate the storage for points
59 
60  int index=0,isum=0;
61  const int offset = 3; //offset to match Datafile
62  NekDouble b,c;
63  unsigned int numPoints = GetNumPoints();
64 
65  // initialize values
66  for(unsigned int i=0; i < numPoints-2; ++i)
67  {
68  index += NodalTriFeketeNPTS[i];
69  }
70 
71  for(unsigned int i=0; i < NodalTriFeketeNPTS[numPoints-2]; ++i, ++index)
72  {
73  if(int(NodalTriFeketeData[index][0]))
74  {
75  b = NodalTriFeketeData[index][4];
76  c = NodalTriFeketeData[index][5];
77 
78  m_points[0][isum] = 2.0*b - 1.0;
79  m_points[1][isum] = 2.0*c - 1.0;
80  isum++;
81  continue;
82  }//end symmetry1
83 
84 
85  if(int(NodalTriFeketeData[index][1]) == 1)
86  {
87  for(unsigned int j=0; j < 3; ++j)
88  {
89  b = NodalTriFeketeData[index][offset+perm3A_2d[j][1]];
90  c = NodalTriFeketeData[index][offset+perm3A_2d[j][2]];
91  m_points[0][isum] = 2.0*b - 1.0;
92  m_points[1][isum] = 2.0*c - 1.0;
93  isum++;
94  }//end j
95  continue;
96  }//end symmetry3a
97 
98  if(int(NodalTriFeketeData[index][1]) == 2)
99  {
100  for(unsigned int j=0; j < 3; ++j)
101  {
102  b = NodalTriFeketeData[index][offset+perm3B_2d[j][1]];
103  c = NodalTriFeketeData[index][offset+perm3B_2d[j][2]];
104  m_points[0][isum] = 2.0*b - 1.0;
105  m_points[1][isum] = 2.0*c - 1.0;
106  isum++;
107  }//end j
108  continue;
109  }//end symmetry3b
110 
111 
112  if(int(NodalTriFeketeData[index][2]))
113  {
114  for(unsigned int j=0; j < 6; ++j)
115  {
116  b = NodalTriFeketeData[index][offset+perm6_2d[j][1]];
117  c = NodalTriFeketeData[index][offset+perm6_2d[j][2]];
118  m_points[0][isum] = 2.0*b - 1.0;
119  m_points[1][isum] = 2.0*c - 1.0;
120  isum++;
121  }//end j
122  continue;
123  }//end symmetry6
124  }//end npts
125 
127 
128  ASSERTL1((static_cast<unsigned int>(isum)==m_pointsKey.GetTotNumPoints()),"sum not equal to npts");
129 
131  numPoints - 1, m_points[0], m_points[1]);
132  }
133 
135  {
136  // Allocate the storage for points
138 
139  typedef DataType T;
140 
141  // Solve the Vandermonde system of integrals for the weight vector
142  NekVector<T> w = m_util->GetWeights();
143  m_weights = Array<OneD,T>( w.GetRows(), w.GetPtr() );
144 
145  }
146 
147  // ////////////////////////////////////////
148  // CalculateInterpMatrix()
150  Array<OneD, NekDouble>& interp)
151  {
153  xi[0] = xia;
154  xi[1] = yia;
155 
156  boost::shared_ptr<NekMatrix<NekDouble> > mat =
157  m_util->GetInterpolationMatrix(xi);
158  Vmath::Vcopy(mat->GetRows() * mat->GetColumns(), mat->GetRawPtr(),
159  1, &interp[0], 1);
160  }
161 
162  // ////////////////////////////////////////
163  // CalculateDerivMatrix()
165  {
166  // Allocate the derivative matrix.
168 
169  m_derivmatrix[0] = m_util->GetDerivMatrix(0);
170  m_derivmatrix[1] = m_util->GetDerivMatrix(1);
171  }
172 
173  boost::shared_ptr<PointsBaseType> NodalTriFekete::Create(const PointsKey &key)
174  {
175  boost::shared_ptr<PointsBaseType> returnval(MemoryManager<NodalTriFekete>::AllocateSharedPtr(key));
176  returnval->Initialize();
177  return returnval;
178  }
179 
181  {
182  int i,j;
183  int cnt;
184  int istart,iend;
185 
186  const int nVerts = 3;
187  const int nEdgeInteriorPoints = GetNumPoints()-2;
188  const int nBoundaryPoints = 3*nEdgeInteriorPoints + 3;
189 
190  if(nEdgeInteriorPoints==0)
191  {
192  return;
193  }
194 
195  // group the points of edge 1 together;
196  istart = nVerts;
197  for(i = cnt = istart; i < nBoundaryPoints; i++)
198  {
199  if( fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
200  {
201  std::swap(m_points[0][cnt], m_points[0][i]);
202  std::swap(m_points[1][cnt], m_points[1][i]);
203  cnt++;
204  }
205  }
206 
207  // bubble sort edge 1 (counterclockwise numbering)
208  iend = istart + nEdgeInteriorPoints;
209  for(i = istart; i < iend; i++)
210  {
211  for(j = istart+1; j < iend; j++)
212  {
213  if(m_points[0][j] < m_points[0][j-1])
214  {
215  std::swap(m_points[0][j], m_points[0][j-1]);
216  std::swap(m_points[1][j], m_points[1][j-1]);
217  }
218  }
219  }
220 
221  // group the points of edge 2 together;
222  istart = iend;
223  for(i = cnt = istart; i < nBoundaryPoints; i++)
224  {
225  if( fabs(m_points[1][i]+m_points[0][i]) < NekConstants::kNekZeroTol)
226  {
227  std::swap(m_points[0][cnt], m_points[0][i]);
228  std::swap(m_points[1][cnt], m_points[1][i]);
229  cnt++;
230  }
231  }
232 
233  // bubble sort edge 2 (counterclockwise numbering)
234  iend = istart + nEdgeInteriorPoints;
235  for(i = istart; i < iend; i++)
236  {
237  for(j = istart+1; j < iend; j++)
238  {
239  if(m_points[1][j] < m_points[1][j-1])
240  {
241  std::swap(m_points[0][j], m_points[0][j-1]);
242  std::swap(m_points[1][j], m_points[1][j-1]);
243  }
244  }
245  }
246 
247  // group the points of edge 3 together;
248  istart = iend;
249  for(i = cnt = istart; i < nBoundaryPoints; i++)
250  {
251  if( fabs(m_points[0][i]+1.0) < NekConstants::kNekZeroTol)
252  {
253  std::swap(m_points[0][cnt], m_points[0][i]);
254  std::swap(m_points[1][cnt], m_points[1][i]);
255  cnt++;
256  }
257  }
258  // bubble sort edge 3 (counterclockwise numbering)
259  iend = istart + nEdgeInteriorPoints;
260  for(i = istart; i < iend; i++)
261  {
262  for(j = istart+1; j < iend; j++)
263  {
264  if(m_points[1][j] > m_points[1][j-1])
265  {
266  std::swap(m_points[0][j], m_points[0][j-1]);
267  std::swap(m_points[1][j], m_points[1][j-1]);
268  }
269  }
270  }
271 
272  if(GetNumPoints() < 5)
273  {
274  //at numpoints = 4 there is only one interior point so doesnt
275  //need sorting
276  return;
277  }
278 
279  //someone forgot to finish this piece of code and tell anyone
280  //that they didnt
281  //face interior nodes needs to be considered
282  //make a copy of the unsorted nodes
283  //bubble sort by smallest y
284  //which will put them into sets of ever decreasing size
285  //which can be bubble sorted by x to obtain the distrobution
286 
287  Array<OneD, NekDouble> xc(m_points[0].num_elements() - iend);
288  Array<OneD, NekDouble> yc(m_points[0].num_elements() - iend);
289  int ct = 0;
290  for(i = iend; i < m_points[0].num_elements(); i++, ct++)
291  {
292  xc[ct] = m_points[0][i];
293  yc[ct] = m_points[1][i];
294  }
295 
296  //sort smallest first
297  bool repeat = true;
298  while(repeat)
299  {
300  repeat = false;
301  for(i = 0; i < xc.num_elements() - 1; i++)
302  {
303  if(yc[i] > yc[i+1])
304  {
305  std::swap(xc[i],xc[i+1]);
306  std::swap(yc[i],yc[i+1]);
307  repeat = true;
308  }
309  }
310  }
311 
312  int offset = 0;
313  int npl = GetNumPoints() - 3;
314  while(npl > 1)
315  {
316  repeat = true;
317  while(repeat)
318  {
319  repeat = false;
320  for(i = offset; i < offset + npl - 1; i++)
321  {
322  if(xc[i] > xc[i+1])
323  {
324  std::swap(xc[i],xc[i+1]);
325  std::swap(yc[i],yc[i+1]);
326  repeat = true;
327  }
328  }
329  }
330  offset += npl;
331  npl--;
332  }
333 
334  //copy back in
335  ct = 0;
336  for(i = iend; i < m_points[0].num_elements(); i++, ct++)
337  {
338  m_points[0][i] = xc[ct];
339  m_points[1][i] = yc[ct];
340  }
341  return;
342  }
343 
344 
345  } // end of namespace stdregion
346 } // end of namespace stdregion
347 
boost::shared_ptr< NodalUtilTriangle > m_util
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
static const unsigned int perm3B_2d[3][3]
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
MatrixSharedPtrType m_derivmatrix[3]
Definition: Points.h:373
Array< OneD, DataType > m_points[3]
Definition: Points.h:371
static const unsigned int NodalTriFeketeNPTS[NodalTriFeketeAvailable]
size_type num_elements() const
Returns the array's size.
static const NekDouble kNekZeroTol
void CalculateInterpMatrix(const Array< OneD, const NekDouble > &xi, const Array< OneD, const NekDouble > &yi, Array< OneD, NekDouble > &interp)
unsigned int GetNumPoints() const
Definition: Points.h:268
unsigned int GetTotNumPoints() const
Definition: Points.h:179
Array< OneD, DataType > m_weights
Definition: Points.h:372
Defines a specification for a set of points.
Definition: Points.h:58
double NekDouble
static const unsigned int perm3A_2d[3][3]
unsigned int GetRows() const
Definition: NekVector.cpp:218
static boost::shared_ptr< PointsBaseType > Create(const PointsKey &key)
static const unsigned int perm6_2d[6][3]
static const NekDouble NodalTriFeketeData[][6]
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
Array< OneD, DataType > & GetPtr()
Definition: NekVector.cpp:230