Nektar++
Loading...
Searching...
No Matches
Functions
Nektar::QuadEquiSpaced Namespace Reference

Functions

 BOOST_AUTO_TEST_CASE (TestQuadExpInterpPhysToEquiSpaced)
 
 BOOST_AUTO_TEST_CASE (TestTriExpInterpPhysToEquiSpaced)
 
 BOOST_AUTO_TEST_CASE (TestTetExpInterpPhysToEquiSpaced)
 
 BOOST_AUTO_TEST_CASE (TestPrismExpInterpPhysToEquiSpaced)
 
 BOOST_AUTO_TEST_CASE (TestQuadExpEquiSpacedToPhys)
 
 BOOST_AUTO_TEST_CASE (TestTriExpEquiSpacedToPhys)
 
 BOOST_AUTO_TEST_CASE (TestTriExpInterpGLLSpaced)
 
 BOOST_AUTO_TEST_CASE (TestTetpInterpPhysToGLLSpaced)
 
 BOOST_AUTO_TEST_CASE (TestPrismpInterpPhysToGLLSpaced)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestPrismExpInterpPhysToEquiSpaced  )

Definition at line 243 of file TestEquiSpaced.cpp.

244{
245 using namespace LibUtilities;
246
247 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
248 PointsType PointsTypeDir2 = eGaussLobattoLegendre;
249 PointsType PointsTypeDir3 = eGaussRadauMAlpha1Beta0;
250 BasisType basisTypeDir1 = eModified_A;
251 BasisType basisTypeDir2 = eModified_A;
252 BasisType basisTypeDir3 = eModified_B;
253
254 unsigned int numPoints = 10;
255 unsigned int numEQ = 8;
256
257 // Set up standard element.
258 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
259 const PointsKey PointsKeyDir2(numPoints, PointsTypeDir2);
260 const PointsKey PointsKeyDir3(numPoints - 1, PointsTypeDir3);
261 const BasisKey basisKeyDir1(basisTypeDir1, numEQ, PointsKeyDir1);
262 const BasisKey basisKeyDir2(basisTypeDir2, numEQ, PointsKeyDir2);
263 const BasisKey basisKeyDir3(basisTypeDir3, numEQ, PointsKeyDir3);
264
265 StdRegions::StdPrismExpSharedPtr Exp =
266 MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
267 basisKeyDir1, basisKeyDir2, basisKeyDir3);
268
269 // define an equispaced Tet points
270 PointsType PointsTypeEq = eNodalPrismEvenlySpaced;
271
272 StdRegions::StdTetExpSharedPtr ExpEq =
273 MemoryManager<StdRegions::StdNodalTetExp>::AllocateSharedPtr(
274 basisKeyDir1, basisKeyDir2, basisKeyDir3, PointsTypeEq);
275
276 // Get coordinates at quadrature points
277 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
278 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
279 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
280 Exp->GetCoords(c0, c1, c2);
281
282 // Get coordinates at equispaced points
283 Array<OneD, NekDouble> ceq0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
284 Array<OneD, NekDouble> ceq1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
285 Array<OneD, NekDouble> ceq2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
286 ExpEq->GetCoords(ceq0, ceq1, ceq2);
287
288 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(Exp->GetNcoeffs());
289 Array<OneD, NekDouble> outeq = Array<OneD, NekDouble>(Exp->GetNcoeffs());
290 double epsilon = 1.0e-8;
291
292 Array<OneD, int> sorted;
293 LibUtilities::NodalUtilPrism::CartesianOrdering(numEQ, sorted);
294
295 // compare x-coordinates
296 Exp->PhysInterpToSimplexEquiSpaced(c0, out, numEQ);
297 int cnt = 0;
298 for (int k = 0; k < numEQ; ++k)
299 {
300 for (int j = 0; j < numEQ; ++j)
301 {
302 for (int i = 0; i < numEQ - k; ++i)
303 {
304 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * i / (numEQ - 1.0),
305 epsilon);
306 }
307 }
308 }
309
310 // compare y-coordinates
311 Exp->PhysInterpToSimplexEquiSpaced(c1, out, numEQ);
312 cnt = 0;
313 for (int k = 0; k < numEQ; ++k)
314 {
315 for (int j = 0; j < numEQ; ++j)
316 {
317 for (int i = 0; i < numEQ - k; ++i)
318 {
319 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * j / (numEQ - 1.0),
320 epsilon);
321 }
322 }
323 }
324
325 // compare z-coordinates
326 Exp->PhysInterpToSimplexEquiSpaced(c2, out, numEQ);
327 cnt = 0;
328 for (int k = 0; k < numEQ; ++k)
329 {
330 for (int j = 0; j < numEQ; ++j)
331 {
332 for (int i = 0; i < numEQ - k; ++i)
333 {
334 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * k / (numEQ - 1.0),
335 epsilon);
336 }
337 }
338 }
339}
Nektar::LibUtilities::BasisKey
Describes the specification for a Basis.
Definition Basis.h:45
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition Points.h:50
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition NekMemoryManager.hpp:81
Nektar::LibUtilities::eNodalPrismEvenlySpaced
@ eNodalPrismEvenlySpaced
3D Evenly-spaced points on a Prism
Definition PointsType.h:86
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition PointsType.h:51
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition BasisType.h:49
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition BasisType.h:48
Nektar::StdRegions::StdPrismExpSharedPtr
std::shared_ptr< StdPrismExp > StdPrismExpSharedPtr
Definition StdPrismExp.h:184
Nektar::StdRegions::StdTetExpSharedPtr
std::shared_ptr< StdTetExp > StdTetExpSharedPtr
Definition StdTetExp.h:187

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NodalUtilPrism::CartesianOrdering(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, and Nektar::LibUtilities::eNodalPrismEvenlySpaced.

◆ BOOST_AUTO_TEST_CASE() [2/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestPrismpInterpPhysToGLLSpaced  )

Definition at line 187 of file TestGLLSpaced.cpp.

188{
189 using namespace LibUtilities;
190
191 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
192 PointsType PointsTypeDir2 = eGaussLobattoLegendre;
193 PointsType PointsTypeDir3 = eGaussRadauMAlpha1Beta0;
194 BasisType basisTypeDir1 = eModified_A;
195 BasisType basisTypeDir2 = eModified_A;
196 BasisType basisTypeDir3 = eModified_B;
197
198 unsigned int numPoints = 5;
199 unsigned int numPt = 4;
200
201 // Set up standard element.
202 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
203 const PointsKey PointsKeyDir2(numPoints, PointsTypeDir2);
204 const PointsKey PointsKeyDir3(numPoints - 1, PointsTypeDir3);
205 const BasisKey basisKeyDir1(basisTypeDir1, numPt, PointsKeyDir1);
206 const BasisKey basisKeyDir2(basisTypeDir2, numPt, PointsKeyDir2);
207 const BasisKey basisKeyDir3(basisTypeDir3, numPt, PointsKeyDir3);
208
209 StdRegions::StdPrismExpSharedPtr Exp =
210 MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
211 basisKeyDir1, basisKeyDir2, basisKeyDir3);
212
213 // define Prism points
214 PointsType PointsType = eNodalPrismElec;
215
216 StdRegions::StdPrismExpSharedPtr ExpGll =
217 MemoryManager<StdRegions::StdNodalPrismExp>::AllocateSharedPtr(
218 basisKeyDir1, basisKeyDir2, basisKeyDir3, PointsType);
219
220 // Get coordinates at quadrature points
221 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
222 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
223 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
224 Exp->GetCoords(c0, c1, c2);
225
226 // Get coordinates at gll points
227 Array<OneD, NekDouble> cgll0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
228 Array<OneD, NekDouble> cgll1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
229 Array<OneD, NekDouble> cgll2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
230 ExpGll->GetCoords(cgll0, cgll1, cgll2);
231
232 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(Exp->GetNcoeffs());
233 Array<OneD, NekDouble> outgll = Array<OneD, NekDouble>(Exp->GetNcoeffs());
234 double epsilon = 1.0e-8;
235
236 Array<OneD, int> sorted;
237 LibUtilities::NodalUtilPrism::CartesianOrdering(numPt, sorted);
238
239 // compare x-coordinates
240 Exp->PhysInterpToGLL(c0, out, numPt);
241 ExpGll->FwdTrans(cgll0, outgll);
242 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
243 {
244 BOOST_CHECK_CLOSE(out[i], outgll[sorted[i]], epsilon);
245 }
246
247 // compare y-coordinates
248 Exp->PhysInterpToGLL(c1, out, numPt);
249 ExpGll->FwdTrans(cgll1, outgll);
250 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
251 {
252 BOOST_CHECK_CLOSE(out[i], outgll[sorted[i]], epsilon);
253 }
254
255 // compare z-coordinates
256 Exp->PhysInterpToGLL(c2, out, numPt);
257 ExpGll->FwdTrans(cgll2, outgll);
258 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
259 {
260 BOOST_CHECK_CLOSE(out[i], outgll[sorted[i]], epsilon);
261 }
262}
Nektar::LibUtilities::eNodalPrismElec
@ eNodalPrismElec
3D electrostatically spaced points on a Prism
Definition PointsType.h:87

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NodalUtilPrism::CartesianOrdering(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, and Nektar::LibUtilities::eNodalPrismElec.

◆ BOOST_AUTO_TEST_CASE() [3/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestQuadExpEquiSpacedToPhys  )

Definition at line 341 of file TestEquiSpaced.cpp.

342{
343 LibUtilities::PointsType PointsTypeDir1 =
344 Nektar::LibUtilities::eGaussLobattoLegendre;
345 LibUtilities::BasisType basisTypeDir1 = Nektar::LibUtilities::eModified_A;
346 unsigned int numPoints = 10;
347 unsigned int numModes = 8;
348 const Nektar::LibUtilities::PointsKey PointsKeyDir1(numPoints,
349 PointsTypeDir1);
350 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
351 PointsKeyDir1);
352
353 StdRegions::StdQuadExpSharedPtr Exp =
354 MemoryManager<Nektar::StdRegions::StdQuadExp>::AllocateSharedPtr(
355 basisKeyDir1, basisKeyDir1);
356
357 unsigned int numEQ = 4;
358 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
359 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
360 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
361 Array<OneD, NekDouble> phys = Array<OneD, NekDouble>(Exp->GetTotPoints());
362 Array<OneD, NekDouble> in = Array<OneD, NekDouble>(numEQ * numEQ);
363
364 double epsilon = 1.0e-8;
365
366 Exp->GetCoords(c0, c1, c2);
367
368 for (int j = 0, cnt = 0; j < numEQ; ++j)
369 {
370 for (int i = 0; i < numEQ; ++i)
371 {
372 in[cnt++] = -1.0 + 2.0 * i / (numEQ - 1.0);
373 }
374 }
375
376 Exp->EquiSpacedToPhys(numEQ, in, phys);
377 for (int j = 0, cnt = 0; j < numPoints; ++j)
378 {
379 for (int i = 0; i < numPoints; ++i)
380 {
381 BOOST_CHECK_CLOSE(phys[cnt], c0[cnt], epsilon);
382 cnt++;
383 }
384 }
385
386 for (int j = 0, cnt = 0; j < numEQ; ++j)
387 {
388 for (int i = 0; i < numEQ; ++i)
389 {
390 in[cnt++] = -1.0 + 2.0 * j / (numEQ - 1.0);
391 }
392 }
393 Exp->EquiSpacedToPhys(numEQ, in, phys);
394 for (int j = 0, cnt = 0; j < numPoints; ++j)
395 {
396 for (int i = 0; i < numPoints; ++i)
397 {
398 BOOST_CHECK_CLOSE(phys[cnt], c1[cnt], epsilon);
399 cnt++;
400 }
401 }
402}
Nektar::StdRegions::StdQuadExpSharedPtr
std::shared_ptr< StdQuadExp > StdQuadExpSharedPtr
Definition StdQuadExp.h:181

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, and Nektar::LibUtilities::eModified_A.

◆ BOOST_AUTO_TEST_CASE() [4/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestQuadExpInterpPhysToEquiSpaced  )

Definition at line 47 of file TestEquiSpaced.cpp.

48{
49
50 LibUtilities::PointsType PointsTypeDir1 =
51 Nektar::LibUtilities::eGaussLobattoLegendre;
52 LibUtilities::BasisType basisTypeDir1 = Nektar::LibUtilities::eModified_A;
53 unsigned int numPoints = 6;
54 const Nektar::LibUtilities::PointsKey PointsKeyDir1(numPoints,
55 PointsTypeDir1);
56 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
57 PointsKeyDir1);
58
59 StdRegions::StdQuadExpSharedPtr Exp =
60 MemoryManager<Nektar::StdRegions::StdQuadExp>::AllocateSharedPtr(
61 basisKeyDir1, basisKeyDir1);
62
63 unsigned int numEQ = 4;
64 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
65 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
66 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
67 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(numEQ * numEQ);
68
69 double epsilon = 1.0e-8;
70
71 Exp->GetCoords(c0, c1, c2);
72
73 Exp->PhysInterpToSimplexEquiSpaced(c0, out, numEQ);
74 for (int j = 0, cnt = 0; j < numEQ; ++j)
75 {
76 for (int i = 0; i < numEQ; ++i)
77 {
78 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * i / (numEQ - 1.0),
79 epsilon);
80 }
81 }
82
83 Exp->PhysInterpToSimplexEquiSpaced(c1, out, numEQ);
84 for (int j = 0, cnt = 0; j < numEQ; ++j)
85 {
86 for (int i = 0; i < numEQ; ++i)
87 {
88 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * j / (numEQ - 1.0),
89 epsilon);
90 }
91 }
92}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, and Nektar::LibUtilities::eModified_A.

◆ BOOST_AUTO_TEST_CASE() [5/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestTetExpInterpPhysToEquiSpaced  )

Definition at line 145 of file TestEquiSpaced.cpp.

146{
147 using namespace LibUtilities;
148
149 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
150 PointsType PointsTypeDir2 = eGaussRadauMAlpha1Beta0;
151 PointsType PointsTypeDir3 = eGaussRadauMAlpha2Beta0;
152 BasisType basisTypeDir1 = eModified_A;
153 BasisType basisTypeDir2 = eModified_B;
154 BasisType basisTypeDir3 = eModified_C;
155
156 unsigned int numPoints = 10;
157 unsigned int numEQ = 8;
158
159 // Set up standard element.
160 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
161 const PointsKey PointsKeyDir2(numPoints - 1, PointsTypeDir2);
162 const PointsKey PointsKeyDir3(numPoints - 1, PointsTypeDir3);
163 const BasisKey basisKeyDir2(basisTypeDir2, numEQ, PointsKeyDir2);
164 const BasisKey basisKeyDir1(basisTypeDir1, numEQ, PointsKeyDir1);
165 const BasisKey basisKeyDir3(basisTypeDir3, numEQ, PointsKeyDir3);
166
167 StdRegions::StdTetExpSharedPtr Exp =
168 MemoryManager<StdRegions::StdTetExp>::AllocateSharedPtr(
169 basisKeyDir1, basisKeyDir2, basisKeyDir3);
170
171 // define an equispaced Tet points
172 PointsType PointsTypeEq = eNodalTetEvenlySpaced;
173
174 StdRegions::StdTetExpSharedPtr ExpEq =
175 MemoryManager<StdRegions::StdNodalTetExp>::AllocateSharedPtr(
176 basisKeyDir1, basisKeyDir2, basisKeyDir3, PointsTypeEq);
177
178 // Get coordinates at quadrature points
179 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
180 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
181 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
182 Exp->GetCoords(c0, c1, c2);
183
184 // Get coordinates at equispaced points
185 Array<OneD, NekDouble> ceq0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
186 Array<OneD, NekDouble> ceq1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
187 Array<OneD, NekDouble> ceq2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
188 ExpEq->GetCoords(ceq0, ceq1, ceq2);
189
190 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(Exp->GetNcoeffs());
191 Array<OneD, NekDouble> outeq = Array<OneD, NekDouble>(Exp->GetNcoeffs());
192 double epsilon = 1.0e-8;
193
194 Array<OneD, int> sorted;
195 LibUtilities::NodalUtilTetrahedron::CartesianOrdering(numEQ, sorted);
196
197 // compare x-coordinates
198 Exp->PhysInterpToSimplexEquiSpaced(c0, out, numEQ);
199 int cnt = 0;
200 for (int k = 0; k < numEQ; ++k)
201 {
202 for (int j = 0; j < numEQ - k; ++j)
203 {
204 for (int i = 0; i < numEQ - k - j; ++i)
205 {
206 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * i / (numEQ - 1.0),
207 epsilon);
208 }
209 }
210 }
211
212 // compare y-coordinates
213 Exp->PhysInterpToSimplexEquiSpaced(c1, out, numEQ);
214 cnt = 0;
215 for (int k = 0; k < numEQ; ++k)
216 {
217 for (int j = 0; j < numEQ - k; ++j)
218 {
219 for (int i = 0; i < numEQ - k - j; ++i)
220 {
221 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * j / (numEQ - 1.0),
222 epsilon);
223 }
224 }
225 }
226
227 // compare z-coordinates
228 Exp->PhysInterpToSimplexEquiSpaced(c2, out, numEQ);
229 cnt = 0;
230 for (int k = 0; k < numEQ; ++k)
231 {
232 for (int j = 0; j < numEQ - k; ++j)
233 {
234 for (int i = 0; i < numEQ - k - j; ++i)
235 {
236 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * k / (numEQ - 1.0),
237 epsilon);
238 }
239 }
240 }
241}
Nektar::LibUtilities::eNodalTetEvenlySpaced
@ eNodalTetEvenlySpaced
3D Evenly-spaced points on a Tetrahedron
Definition PointsType.h:84
Nektar::LibUtilities::eModified_C
@ eModified_C
Principle Modified Functions .
Definition BasisType.h:50

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NodalUtilTetrahedron::CartesianOrdering(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, and Nektar::LibUtilities::eNodalTetEvenlySpaced.

◆ BOOST_AUTO_TEST_CASE() [6/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestTetpInterpPhysToGLLSpaced  )

Definition at line 110 of file TestGLLSpaced.cpp.

111{
112 using namespace LibUtilities;
113
114 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
115 PointsType PointsTypeDir2 = eGaussRadauMAlpha1Beta0;
116 PointsType PointsTypeDir3 = eGaussRadauMAlpha2Beta0;
117 BasisType basisTypeDir1 = eModified_A;
118 BasisType basisTypeDir2 = eModified_B;
119 BasisType basisTypeDir3 = eModified_C;
120
121 unsigned int numPoints = 10;
122 unsigned int numEQ = 8;
123
124 // Set up standard element.
125 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
126 const PointsKey PointsKeyDir2(numPoints - 1, PointsTypeDir2);
127 const PointsKey PointsKeyDir3(numPoints - 1, PointsTypeDir3);
128 const BasisKey basisKeyDir2(basisTypeDir2, numEQ, PointsKeyDir2);
129 const BasisKey basisKeyDir1(basisTypeDir1, numEQ, PointsKeyDir1);
130 const BasisKey basisKeyDir3(basisTypeDir3, numEQ, PointsKeyDir3);
131
132 StdRegions::StdTetExpSharedPtr Exp =
133 MemoryManager<StdRegions::StdTetExp>::AllocateSharedPtr(
134 basisKeyDir1, basisKeyDir2, basisKeyDir3);
135
136 // define an equispaced Tet points
137 PointsType PointsTypeEq = eNodalTetElec;
138
139 StdRegions::StdTetExpSharedPtr ExpEq =
140 MemoryManager<StdRegions::StdNodalTetExp>::AllocateSharedPtr(
141 basisKeyDir1, basisKeyDir2, basisKeyDir3, PointsTypeEq);
142
143 // Get coordinates at quadrature points
144 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
145 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
146 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
147 Exp->GetCoords(c0, c1, c2);
148
149 // Get coordinates at equispaced points
150 Array<OneD, NekDouble> ceq0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
151 Array<OneD, NekDouble> ceq1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
152 Array<OneD, NekDouble> ceq2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
153 ExpEq->GetCoords(ceq0, ceq1, ceq2);
154
155 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(Exp->GetNcoeffs());
156 Array<OneD, NekDouble> outeq = Array<OneD, NekDouble>(Exp->GetNcoeffs());
157 double epsilon = 1.0e-8;
158
159 Array<OneD, int> sorted;
160 LibUtilities::NodalUtilTetrahedron::CartesianOrdering(numEQ, sorted);
161
162 // compare x-coordinates
163 Exp->PhysInterpToGLL(c0, out, numEQ);
164 ExpEq->FwdTrans(ceq0, outeq);
165 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
166 {
167 BOOST_CHECK_CLOSE(out[i], outeq[sorted[i]], epsilon);
168 }
169
170 // compare y-coordinates
171 Exp->PhysInterpToGLL(c1, out, numEQ);
172 ExpEq->FwdTrans(ceq1, outeq);
173 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
174 {
175 BOOST_CHECK_CLOSE(out[i], outeq[sorted[i]], epsilon);
176 }
177
178 // compare z-coordinates
179 Exp->PhysInterpToGLL(c2, out, numEQ);
180 ExpEq->FwdTrans(ceq2, outeq);
181 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
182 {
183 BOOST_CHECK_CLOSE(out[i], outeq[sorted[i]], epsilon);
184 }
185}
Nektar::LibUtilities::eNodalTetElec
@ eNodalTetElec
3D Nodal Electrostatic Points on a Tetrahedron
Definition PointsType.h:85

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NodalUtilTetrahedron::CartesianOrdering(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, and Nektar::LibUtilities::eNodalTetElec.

◆ BOOST_AUTO_TEST_CASE() [7/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestTriExpEquiSpacedToPhys  )

Definition at line 404 of file TestEquiSpaced.cpp.

405{
406
407 LibUtilities::PointsType PointsTypeDir1 =
408 Nektar::LibUtilities::eGaussLobattoLegendre;
409 LibUtilities::PointsType PointsTypeDir2 =
410 Nektar::LibUtilities::eGaussRadauMAlpha1Beta0;
411 Nektar::LibUtilities::BasisType basisTypeDir1 =
412 Nektar::LibUtilities::eModified_A;
413 Nektar::LibUtilities::BasisType basisTypeDir2 =
414 Nektar::LibUtilities::eModified_B;
415
416 unsigned int numPoints = 6;
417
418 const Nektar::LibUtilities::PointsKey PointsKeyDir1(numPoints,
419 PointsTypeDir1);
420 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
421 PointsKeyDir1);
422 const Nektar::LibUtilities::PointsKey PointsKeyDir2(numPoints - 1,
423 PointsTypeDir2);
424 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir2, 4,
425 PointsKeyDir2);
426
427 StdRegions::StdTriExpSharedPtr Exp =
428 MemoryManager<Nektar::StdRegions::StdTriExp>::AllocateSharedPtr(
429 basisKeyDir1, basisKeyDir2);
430
431 unsigned int numEQ = 4;
432 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
433 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
434 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
435 Array<OneD, NekDouble> phys = Array<OneD, NekDouble>(Exp->GetTotPoints());
436 Array<OneD, NekDouble> in = Array<OneD, NekDouble>(numEQ * numEQ);
437
438 double epsilon = 1.0e-8;
439
440 Exp->GetCoords(c0, c1, c2);
441
442 for (int j = 0, cnt = 0; j < numEQ; ++j)
443 {
444 for (int i = 0; i < numEQ - j; ++i)
445 {
446 in[cnt++] = -1.0 + 2.0 * i / (numEQ - 1.0);
447 }
448 }
449 Exp->EquiSpacedToPhys(numEQ, in, phys);
450 for (int j = 0, cnt = 0; j < numPoints - 1; ++j)
451 {
452 for (int i = 0; i < numPoints; ++i)
453 {
454 BOOST_CHECK_CLOSE(phys[cnt], c0[cnt], epsilon);
455 cnt++;
456 }
457 }
458
459 for (int j = 0, cnt = 0; j < numEQ; ++j)
460 {
461 for (int i = 0; i < numEQ - j; ++i)
462 {
463 in[cnt++] = -1.0 + 2.0 * j / (numEQ - 1.0);
464 }
465 }
466 Exp->EquiSpacedToPhys(numEQ, in, phys);
467 for (int j = 0, cnt = 0; j < numPoints - 1; ++j)
468 {
469 for (int i = 0; i < numPoints; ++i)
470 {
471 BOOST_CHECK_CLOSE(phys[cnt], c1[cnt], epsilon);
472 cnt++;
473 }
474 }
475}
Nektar::StdRegions::StdTriExpSharedPtr
std::shared_ptr< StdTriExp > StdTriExpSharedPtr
Definition StdTriExp.h:177

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, and Nektar::LibUtilities::eModified_B.

◆ BOOST_AUTO_TEST_CASE() [8/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestTriExpInterpGLLSpaced  )

Definition at line 46 of file TestGLLSpaced.cpp.

47{
48 using namespace LibUtilities;
49
50 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
51 PointsType PointsTypeDir2 = eGaussRadauMAlpha1Beta0;
52 BasisType basisTypeDir1 = eModified_A;
53 BasisType basisTypeDir2 = eModified_B;
54
55 unsigned int numPoints = 8;
56 unsigned int numEQ = 6;
57
58 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
59 const BasisKey basisKeyDir1(basisTypeDir1, numEQ, PointsKeyDir1);
60 const PointsKey PointsKeyDir2(numPoints - 1, PointsTypeDir2);
61 const BasisKey basisKeyDir2(basisTypeDir2, numEQ, PointsKeyDir2);
62
63 StdRegions::StdTriExpSharedPtr Exp =
64 MemoryManager<Nektar::StdRegions::StdTriExp>::AllocateSharedPtr(
65 basisKeyDir1, basisKeyDir2);
66
67 // define an equispaced Tri points
68 PointsType PointsTypeEq = eNodalTriElec;
69
70 StdRegions::StdTriExpSharedPtr ExpEq =
71 MemoryManager<StdRegions::StdNodalTriExp>::AllocateSharedPtr(
72 basisKeyDir1, basisKeyDir2, PointsTypeEq);
73
74 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
75 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
76 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
77 Exp->GetCoords(c0, c1, c2);
78
79 // Get coordinates at equispaced points
80 Array<OneD, NekDouble> ceq0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
81 Array<OneD, NekDouble> ceq1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
82 Array<OneD, NekDouble> ceq2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
83 ExpEq->GetCoords(ceq0, ceq1, ceq2);
84
85 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(Exp->GetNcoeffs());
86 Array<OneD, NekDouble> outeq = Array<OneD, NekDouble>(Exp->GetNcoeffs());
87
88 double epsilon = 1.0e-8;
89
90 Array<OneD, int> sorted;
91 LibUtilities::NodalUtilTriangle::CartesianOrdering(numEQ, sorted);
92
93 // compare x-coordinates
94 Exp->PhysInterpToGLL(c0, out, numEQ);
95 ExpEq->FwdTrans(ceq0, outeq);
96 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
97 {
98 BOOST_CHECK_CLOSE(out[i], outeq[sorted[i]], epsilon);
99 }
100
101 // compare y-coordinates
102 Exp->PhysInterpToGLL(c1, out, numEQ);
103 ExpEq->FwdTrans(ceq1, outeq);
104 for (int i = 0; i < Exp->GetNcoeffs(); ++i)
105 {
106 BOOST_CHECK_CLOSE(out[i], outeq[sorted[i]], epsilon);
107 }
108}
Nektar::LibUtilities::eNodalTriElec
@ eNodalTriElec
2D Nodal Electrostatic Points on a Triangle
Definition PointsType.h:81

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NodalUtilTriangle::CartesianOrdering(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, and Nektar::LibUtilities::eNodalTriElec.

◆ BOOST_AUTO_TEST_CASE() [9/9]

Nektar::QuadEquiSpaced::BOOST_AUTO_TEST_CASE ( TestTriExpInterpPhysToEquiSpaced  )

Definition at line 94 of file TestEquiSpaced.cpp.

95{
96 using namespace LibUtilities;
97
98 PointsType PointsTypeDir1 = eGaussLobattoLegendre;
99 PointsType PointsTypeDir2 = eGaussRadauMAlpha1Beta0;
100 BasisType basisTypeDir1 = eModified_A;
101 BasisType basisTypeDir2 = eModified_B;
102
103 unsigned int numPoints = 6;
104 unsigned int numEQ = 4;
105
106 const PointsKey PointsKeyDir1(numPoints, PointsTypeDir1);
107 const BasisKey basisKeyDir1(basisTypeDir1, numEQ, PointsKeyDir1);
108 const PointsKey PointsKeyDir2(numPoints - 1, PointsTypeDir2);
109 const BasisKey basisKeyDir2(basisTypeDir2, numEQ, PointsKeyDir2);
110
111 StdRegions::StdTriExpSharedPtr Exp =
112 MemoryManager<Nektar::StdRegions::StdTriExp>::AllocateSharedPtr(
113 basisKeyDir1, basisKeyDir2);
114
115 Array<OneD, NekDouble> c0 = Array<OneD, NekDouble>(Exp->GetTotPoints());
116 Array<OneD, NekDouble> c1 = Array<OneD, NekDouble>(Exp->GetTotPoints());
117 Array<OneD, NekDouble> c2 = Array<OneD, NekDouble>(Exp->GetTotPoints());
118 Array<OneD, NekDouble> out = Array<OneD, NekDouble>(numEQ * numEQ);
119
120 double epsilon = 1.0e-8;
121
122 Exp->GetCoords(c0, c1, c2);
123
124 Exp->PhysInterpToSimplexEquiSpaced(c0, out, numEQ);
125 for (int j = 0, cnt = 0; j < numEQ; ++j)
126 {
127 for (int i = 0; i < numEQ - j; ++i)
128 {
129 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * i / (numEQ - 1.0),
130 epsilon);
131 }
132 }
133
134 Exp->PhysInterpToSimplexEquiSpaced(c1, out, numEQ);
135 for (int j = 0, cnt = 0; j < numEQ; ++j)
136 {
137 for (int i = 0; i < numEQ - j; ++i)
138 {
139 BOOST_CHECK_CLOSE(out[cnt++], -1.0 + 2.0 * j / (numEQ - 1.0),
140 epsilon);
141 }
142 }
143}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, and Nektar::LibUtilities::eModified_B.

Generated on Sat Jul 4 2026 01:02:31 for Nektar++ by doxygen 1.9.8