Nektar++
Loading...
Searching...
No Matches
TestSegCollection.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: TestSegCollection.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:
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <Collections/Collection.h>
36#include <Collections/CollectionOptimisation.h>
37#include <LocalRegions/SegExp.h>
38#include <SpatialDomains/MeshGraph.h>
39#include <boost/test/tools/floating_point_comparison.hpp>
40#include <boost/test/unit_test.hpp>
41
42namespace Nektar::SegCollectionTests
43{
44SpatialDomains::SegGeomUniquePtr CreateSegGeom(unsigned int id,
45 SpatialDomains::PointGeom *v0,
46 SpatialDomains::PointGeom *v1,
47 int coordim = 1)
48{
49 std::array<SpatialDomains::PointGeom *, 2> vertices = {v0, v1};
50 SpatialDomains::SegGeomUniquePtr result(
51 new SpatialDomains::SegGeom(id, coordim, vertices));
52 return result;
53}
54
55BOOST_AUTO_TEST_CASE(TestSegBwdTrans_StdMat_UniformP)
56{
57 SpatialDomains::PointGeomUniquePtr v0(
58 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
59 SpatialDomains::PointGeomUniquePtr v1(
60 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
61
62 SpatialDomains::SegGeomUniquePtr segGeom =
63 CreateSegGeom(0, v0.get(), v1.get());
64
65 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
66 Nektar::LibUtilities::eGaussLobattoLegendre;
67 Nektar::LibUtilities::BasisType basisTypeDir1 =
68 Nektar::LibUtilities::eModified_A;
69 unsigned int numSegPoints = 6;
70 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
71 segPointsTypeDir1);
72 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
73 segPointsKeyDir1);
74
75 Nektar::LocalRegions::SegExpSharedPtr Exp =
76 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
77 basisKeyDir1, segGeom.get());
78
79 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
80 CollExp.push_back(Exp);
81
82 LibUtilities::SessionReaderSharedPtr dummySession;
83 Collections::CollectionOptimisation colOpt(dummySession, 1,
84 Collections::eStdMat);
85 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
86 Collections::Collection c(CollExp, impTypes);
87 c.Initialise(Collections::eBwdTrans);
88
89 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
90 for (int i = 0; i < coeffs.size(); ++i)
91 {
92 coeffs[i] = i + 1;
93 }
94 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
95 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
96
97 Exp->BwdTrans(coeffs, phys1);
98 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
99
100 double epsilon = 1.0e-8;
101 for (int i = 0; i < phys1.size(); ++i)
102 {
103 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
104 }
105}
106
107BOOST_AUTO_TEST_CASE(TestSegBwdTrans_StdMat_UniformP_MultiElmt)
108{
109 SpatialDomains::PointGeomUniquePtr v0(
110 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
111 SpatialDomains::PointGeomUniquePtr v1(
112 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
113
114 SpatialDomains::SegGeomUniquePtr segGeom =
115 CreateSegGeom(0, v0.get(), v1.get());
116
117 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
118 Nektar::LibUtilities::eGaussLobattoLegendre;
119 Nektar::LibUtilities::BasisType basisTypeDir1 =
120 Nektar::LibUtilities::eModified_A;
121 unsigned int numSegPoints = 6;
122 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
123 segPointsTypeDir1);
124 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
125 segPointsKeyDir1);
126
127 Nektar::LocalRegions::SegExpSharedPtr Exp =
128 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
129 basisKeyDir1, segGeom.get());
130
131 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
132
133 int nelmts = 10;
134 for (int i = 0; i < nelmts; ++i)
135 {
136 CollExp.push_back(Exp);
137 }
138
139 LibUtilities::SessionReaderSharedPtr dummySession;
140 Collections::CollectionOptimisation colOpt(dummySession, 1,
141 Collections::eStdMat);
142 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
143 Collections::Collection c(CollExp, impTypes);
144 c.Initialise(Collections::eBwdTrans);
145
146 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
147 for (int i = 0; i < coeffs.size(); ++i)
148 {
149 coeffs[i] = i + 1;
150 }
151 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
152 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
153
154 for (int i = 0; i < nelmts; ++i)
155 {
156 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
157 tmp = phys1 + i * Exp->GetTotPoints());
158 }
159 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
160
161 double epsilon = 1.0e-8;
162 for (int i = 0; i < phys1.size(); ++i)
163 {
164 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
165 }
166}
167
168BOOST_AUTO_TEST_CASE(TestSegBwdTrans_IterPerExp_UniformP)
169{
170 SpatialDomains::PointGeomUniquePtr v0(
171 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
172 SpatialDomains::PointGeomUniquePtr v1(
173 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
174
175 SpatialDomains::SegGeomUniquePtr segGeom =
176 CreateSegGeom(0, v0.get(), v1.get());
177
178 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
179 Nektar::LibUtilities::eGaussLobattoLegendre;
180 Nektar::LibUtilities::BasisType basisTypeDir1 =
181 Nektar::LibUtilities::eModified_A;
182 unsigned int numSegPoints = 6;
183 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
184 segPointsTypeDir1);
185 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
186 segPointsKeyDir1);
187
188 Nektar::LocalRegions::SegExpSharedPtr Exp =
189 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
190 basisKeyDir1, segGeom.get());
191
192 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
193 CollExp.push_back(Exp);
194
195 LibUtilities::SessionReaderSharedPtr dummySession;
196 Collections::CollectionOptimisation colOpt(dummySession, 1,
197 Collections::eIterPerExp);
198 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
199 Collections::Collection c(CollExp, impTypes);
200 c.Initialise(Collections::eBwdTrans);
201
202 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
203 for (int i = 0; i < coeffs.size(); ++i)
204 {
205 coeffs[i] = i + 1;
206 }
207 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
208 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
209
210 Exp->BwdTrans(coeffs, phys1);
211 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
212
213 double epsilon = 1.0e-8;
214 for (int i = 0; i < phys1.size(); ++i)
215 {
216 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
217 }
218}
219
220BOOST_AUTO_TEST_CASE(TestSegBwdTrans_SumFac_UniformP)
221{
222 SpatialDomains::PointGeomUniquePtr v0(
223 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
224 SpatialDomains::PointGeomUniquePtr v1(
225 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
226
227 SpatialDomains::SegGeomUniquePtr segGeom =
228 CreateSegGeom(0, v0.get(), v1.get());
229
230 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
231 Nektar::LibUtilities::eGaussLobattoLegendre;
232 Nektar::LibUtilities::BasisType basisTypeDir1 =
233 Nektar::LibUtilities::eModified_A;
234 unsigned int numSegPoints = 6;
235 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
236 segPointsTypeDir1);
237 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
238 segPointsKeyDir1);
239
240 Nektar::LocalRegions::SegExpSharedPtr Exp =
241 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
242 basisKeyDir1, segGeom.get());
243
244 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
245
246 int nelmts = 1;
247 for (int i = 0; i < nelmts; ++i)
248 {
249 CollExp.push_back(Exp);
250 }
251
252 LibUtilities::SessionReaderSharedPtr dummySession;
253 Collections::CollectionOptimisation colOpt(dummySession, 1,
254 Collections::eSumFac);
255 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
256 Collections::Collection c(CollExp, impTypes);
257 c.Initialise(Collections::eBwdTrans);
258
259 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
260 for (int i = 0; i < coeffs.size(); ++i)
261 {
262 coeffs[i] = i + 1;
263 }
264 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
265 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
266
267 for (int i = 0; i < nelmts; ++i)
268 {
269 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
270 tmp = phys1 + i * Exp->GetTotPoints());
271 }
272 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
273
274 double epsilon = 1.0e-8;
275 for (int i = 0; i < phys1.size(); ++i)
276 {
277 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
278 }
279}
280
281BOOST_AUTO_TEST_CASE(TestSegBwdTrans_SumFac_UniformP_MultiElmt)
282{
283 SpatialDomains::PointGeomUniquePtr v0(
284 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
285 SpatialDomains::PointGeomUniquePtr v1(
286 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
287
288 SpatialDomains::SegGeomUniquePtr segGeom =
289 CreateSegGeom(0, v0.get(), v1.get());
290
291 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
292 Nektar::LibUtilities::eGaussLobattoLegendre;
293 Nektar::LibUtilities::BasisType basisTypeDir1 =
294 Nektar::LibUtilities::eModified_A;
295 unsigned int numSegPoints = 6;
296 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
297 segPointsTypeDir1);
298 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
299 segPointsKeyDir1);
300
301 Nektar::LocalRegions::SegExpSharedPtr Exp =
302 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
303 basisKeyDir1, segGeom.get());
304
305 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
306
307 int nelmts = 10;
308 for (int i = 0; i < nelmts; ++i)
309 {
310 CollExp.push_back(Exp);
311 }
312
313 LibUtilities::SessionReaderSharedPtr dummySession;
314 Collections::CollectionOptimisation colOpt(dummySession, 1,
315 Collections::eSumFac);
316 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
317 Collections::Collection c(CollExp, impTypes);
318 c.Initialise(Collections::eBwdTrans);
319
320 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
321 for (int i = 0; i < coeffs.size(); ++i)
322 {
323 coeffs[i] = i + 1;
324 }
325 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
326 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
327
328 for (int i = 0; i < nelmts; ++i)
329 {
330 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
331 tmp = phys1 + i * Exp->GetTotPoints());
332 }
333 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
334
335 double epsilon = 1.0e-8;
336 for (int i = 0; i < phys1.size(); ++i)
337 {
338 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
339 }
340}
341
342BOOST_AUTO_TEST_CASE(TestSegBwdTrans_MatrixFree_UniformP_MultiElmt)
343{
344 SpatialDomains::PointGeomUniquePtr v0(
345 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
346 SpatialDomains::PointGeomUniquePtr v1(
347 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
348
349 SpatialDomains::SegGeomUniquePtr segGeom =
350 CreateSegGeom(0, v0.get(), v1.get());
351
352 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
353 Nektar::LibUtilities::eGaussLobattoLegendre;
354 Nektar::LibUtilities::BasisType basisTypeDir1 =
355 Nektar::LibUtilities::eModified_A;
356 unsigned int numSegPoints = 6;
357 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
358 segPointsTypeDir1);
359 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
360 segPointsKeyDir1);
361
362 Nektar::LocalRegions::SegExpSharedPtr Exp =
363 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
364 basisKeyDir1, segGeom.get());
365
366 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
367
368 int nelmts = 10;
369 for (int i = 0; i < nelmts; ++i)
370 {
371 CollExp.push_back(Exp);
372 }
373
374 LibUtilities::SessionReaderSharedPtr dummySession;
375 Collections::CollectionOptimisation colOpt(dummySession, 1,
376 Collections::eIterPerExp);
377 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
378 impTypes[Collections::eBwdTrans] = Collections::eMatrixFree;
379 Collections::Collection c(CollExp, impTypes);
380 c.Initialise(Collections::eBwdTrans);
381
382 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
383 for (int i = 0; i < coeffs.size(); ++i)
384 {
385 coeffs[i] = i + 1;
386 }
387 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
388 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
389
390 for (int i = 0; i < nelmts; ++i)
391 {
392 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
393 tmp = phys1 + i * Exp->GetTotPoints());
394 }
395 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
396
397 double epsilon = 1.0e-8;
398 for (int i = 0; i < phys1.size(); ++i)
399 {
400 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
401 }
402}
403
404BOOST_AUTO_TEST_CASE(TestSegIProductWRTBase_IterPerExp_UniformP_MultiElmt)
405{
406 SpatialDomains::PointGeomUniquePtr v0(
407 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
408 SpatialDomains::PointGeomUniquePtr v1(
409 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
410
411 SpatialDomains::SegGeomUniquePtr segGeom =
412 CreateSegGeom(0, v0.get(), v1.get());
413
414 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
415 Nektar::LibUtilities::eGaussLobattoLegendre;
416 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
417 segPointsTypeDir1);
418 Nektar::LibUtilities::BasisType basisTypeDir1 =
419 Nektar::LibUtilities::eModified_A;
420 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
421 segPointsKeyDir1);
422
423 Nektar::LocalRegions::SegExpSharedPtr Exp =
424 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
425 basisKeyDir1, segGeom.get());
426
427 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
428
429 int nelmts = 10;
430 for (int i = 0; i < nelmts; ++i)
431 {
432 CollExp.push_back(Exp);
433 }
434
435 LibUtilities::SessionReaderSharedPtr dummySession;
436 Collections::CollectionOptimisation colOpt(dummySession, 1,
437 Collections::eIterPerExp);
438 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
439 Collections::Collection c(CollExp, impTypes);
440 c.Initialise(Collections::eIProductWRTBase);
441
442 const int nq = Exp->GetTotPoints();
443 const int nc = Exp->GetNcoeffs();
444 Array<OneD, NekDouble> xc(nq), yc(nq);
445 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
446 Array<OneD, NekDouble> coeffs1(nelmts * nc);
447 Array<OneD, NekDouble> coeffs2(nelmts * nc);
448
449 Exp->GetCoords(xc, yc);
450
451 for (int i = 0; i < nq; ++i)
452 {
453 phys[i] = sin(xc[i]);
454 }
455 Exp->IProductWRTBase(phys, coeffs1);
456
457 for (int i = 1; i < nelmts; ++i)
458 {
459 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
460 Exp->IProductWRTBase(phys + i * nq, tmp = coeffs1 + i * nc);
461 }
462 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
463
464 double epsilon = 1.0e-8;
465 for (int i = 0; i < coeffs1.size(); ++i)
466 {
467 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
468 }
469}
470
471BOOST_AUTO_TEST_CASE(TestSegIProductWRTBase_StdMat_UniformP_MultiElmt)
472{
473 SpatialDomains::PointGeomUniquePtr v0(
474 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
475 SpatialDomains::PointGeomUniquePtr v1(
476 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
477
478 SpatialDomains::SegGeomUniquePtr segGeom =
479 CreateSegGeom(0, v0.get(), v1.get());
480
481 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
482 Nektar::LibUtilities::eGaussLobattoLegendre;
483 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
484 segPointsTypeDir1);
485 Nektar::LibUtilities::BasisType basisTypeDir1 =
486 Nektar::LibUtilities::eModified_A;
487 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
488 segPointsKeyDir1);
489
490 Nektar::LocalRegions::SegExpSharedPtr Exp =
491 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
492 basisKeyDir1, segGeom.get());
493
494 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
495
496 int nelmts = 10;
497 for (int i = 0; i < nelmts; ++i)
498 {
499 CollExp.push_back(Exp);
500 }
501
502 LibUtilities::SessionReaderSharedPtr dummySession;
503 Collections::CollectionOptimisation colOpt(dummySession, 1,
504 Collections::eStdMat);
505 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
506 Collections::Collection c(CollExp, impTypes);
507 c.Initialise(Collections::eIProductWRTBase);
508
509 const int nq = Exp->GetTotPoints();
510 const int nc = Exp->GetNcoeffs();
511 Array<OneD, NekDouble> xc(nq), yc(nq);
512 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
513 Array<OneD, NekDouble> coeffs1(nelmts * nc);
514 Array<OneD, NekDouble> coeffs2(nelmts * nc);
515
516 Exp->GetCoords(xc, yc);
517
518 for (int i = 0; i < nq; ++i)
519 {
520 phys[i] = sin(xc[i]);
521 }
522 Exp->IProductWRTBase(phys, coeffs1);
523
524 for (int i = 1; i < nelmts; ++i)
525 {
526 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
527 Exp->IProductWRTBase(phys + i * nq, tmp = coeffs1 + i * nc);
528 }
529 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
530
531 double epsilon = 1.0e-8;
532 for (int i = 0; i < coeffs1.size(); ++i)
533 {
534 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
535 }
536}
537
538BOOST_AUTO_TEST_CASE(TestSegIProductWRTBase_SumFac_UniformP_MultiElmt)
539{
540 SpatialDomains::PointGeomUniquePtr v0(
541 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
542 SpatialDomains::PointGeomUniquePtr v1(
543 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
544
545 SpatialDomains::SegGeomUniquePtr segGeom =
546 CreateSegGeom(0, v0.get(), v1.get());
547
548 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
549 Nektar::LibUtilities::eGaussLobattoLegendre;
550 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
551 segPointsTypeDir1);
552 Nektar::LibUtilities::BasisType basisTypeDir1 =
553 Nektar::LibUtilities::eModified_A;
554 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
555 segPointsKeyDir1);
556
557 Nektar::LocalRegions::SegExpSharedPtr Exp =
558 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
559 basisKeyDir1, segGeom.get());
560
561 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
562
563 int nelmts = 10;
564 for (int i = 0; i < nelmts; ++i)
565 {
566 CollExp.push_back(Exp);
567 }
568
569 LibUtilities::SessionReaderSharedPtr dummySession;
570 Collections::CollectionOptimisation colOpt(dummySession, 1,
571 Collections::eSumFac);
572 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
573 Collections::Collection c(CollExp, impTypes);
574 c.Initialise(Collections::eIProductWRTBase);
575
576 const int nq = Exp->GetTotPoints();
577 const int nc = Exp->GetNcoeffs();
578 Array<OneD, NekDouble> xc(nq), yc(nq);
579 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
580 Array<OneD, NekDouble> coeffs1(nelmts * nc);
581 Array<OneD, NekDouble> coeffs2(nelmts * nc);
582
583 Exp->GetCoords(xc, yc);
584
585 for (int i = 0; i < nq; ++i)
586 {
587 phys[i] = sin(xc[i]);
588 }
589 Exp->IProductWRTBase(phys, coeffs1);
590
591 for (int i = 1; i < nelmts; ++i)
592 {
593 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
594 Exp->IProductWRTBase(phys + i * nq, tmp = coeffs1 + i * nc);
595 }
596 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
597
598 double epsilon = 1.0e-8;
599 for (int i = 0; i < coeffs1.size(); ++i)
600 {
601 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
602 }
603}
604
605BOOST_AUTO_TEST_CASE(TestSegIProductWRTBase_MatrixFree_UniformP_MultiElmt)
606{
607 SpatialDomains::PointGeomUniquePtr v0(
608 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
609 SpatialDomains::PointGeomUniquePtr v1(
610 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
611
612 SpatialDomains::SegGeomUniquePtr segGeom =
613 CreateSegGeom(0, v0.get(), v1.get());
614
615 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
616 Nektar::LibUtilities::eGaussLobattoLegendre;
617 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
618 segPointsTypeDir1);
619 Nektar::LibUtilities::BasisType basisTypeDir1 =
620 Nektar::LibUtilities::eModified_A;
621 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
622 segPointsKeyDir1);
623
624 Nektar::LocalRegions::SegExpSharedPtr Exp =
625 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
626 basisKeyDir1, segGeom.get());
627
628 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
629
630 int nelmts = 10;
631 for (int i = 0; i < nelmts; ++i)
632 {
633 CollExp.push_back(Exp);
634 }
635
636 LibUtilities::SessionReaderSharedPtr dummySession;
637 Collections::CollectionOptimisation colOpt(dummySession, 1,
638 Collections::eIterPerExp);
639 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
640 impTypes[Collections::eIProductWRTBase] = Collections::eMatrixFree;
641 Collections::Collection c(CollExp, impTypes);
642 c.Initialise(Collections::eIProductWRTBase);
643
644 const int nq = Exp->GetTotPoints();
645 const int nc = Exp->GetNcoeffs();
646 Array<OneD, NekDouble> xc(nq), yc(nq);
647 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
648 Array<OneD, NekDouble> coeffs1(nelmts * nc);
649 Array<OneD, NekDouble> coeffs2(nelmts * nc);
650
651 Exp->GetCoords(xc, yc);
652
653 for (int i = 0; i < nq; ++i)
654 {
655 phys[i] = sin(xc[i]);
656 }
657 Exp->IProductWRTBase(phys, coeffs1);
658
659 for (int i = 1; i < nelmts; ++i)
660 {
661 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
662 Exp->IProductWRTBase(phys + i * nq, tmp = coeffs1 + i * nc);
663 }
664 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
665
666 double epsilon = 1.0e-8;
667 for (int i = 0; i < coeffs1.size(); ++i)
668 {
669 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
670 }
671}
672
673BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_IterPerExp_UniformP)
674{
675 SpatialDomains::PointGeomUniquePtr v0(
676 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
677 SpatialDomains::PointGeomUniquePtr v1(
678 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
679
680 SpatialDomains::SegGeomUniquePtr segGeom =
681 CreateSegGeom(0, v0.get(), v1.get());
682
683 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
684 Nektar::LibUtilities::eGaussLobattoLegendre;
685 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
686 segPointsTypeDir1);
687 Nektar::LibUtilities::BasisType basisTypeDir1 =
688 Nektar::LibUtilities::eModified_A;
689 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
690 segPointsKeyDir1);
691
692 Nektar::LocalRegions::SegExpSharedPtr Exp =
693 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
694 basisKeyDir1, segGeom.get());
695
696 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
697 CollExp.push_back(Exp);
698
699 LibUtilities::SessionReaderSharedPtr dummySession;
700 Collections::CollectionOptimisation colOpt(dummySession, 1,
701 Collections::eIterPerExp);
702 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
703 Collections::Collection c(CollExp, impTypes);
704 c.Initialise(Collections::ePhysDeriv);
705
706 const int nq = Exp->GetTotPoints();
707 Array<OneD, NekDouble> xc(nq), yc(nq);
708 Array<OneD, NekDouble> phys(nq), tmp;
709 Array<OneD, NekDouble> diff1(nq);
710 Array<OneD, NekDouble> diff2(nq);
711
712 Exp->GetCoords(xc, yc);
713
714 for (int i = 0; i < nq; ++i)
715 {
716 phys[i] = sin(xc[i]);
717 }
718
719 Exp->PhysDeriv(phys, diff1);
720 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
721
722 double epsilon = 1.0e-8;
723 for (int i = 0; i < diff1.size(); ++i)
724 {
725 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
726 }
727}
728
729BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_IterPerExp_UniformP_MultiElmt)
730{
731 SpatialDomains::PointGeomUniquePtr v0(
732 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
733 SpatialDomains::PointGeomUniquePtr v1(
734 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
735
736 SpatialDomains::SegGeomUniquePtr segGeom =
737 CreateSegGeom(0, v0.get(), v1.get());
738
739 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
740 Nektar::LibUtilities::eGaussLobattoLegendre;
741 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
742 segPointsTypeDir1);
743 Nektar::LibUtilities::BasisType basisTypeDir1 =
744 Nektar::LibUtilities::eModified_A;
745 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
746 segPointsKeyDir1);
747
748 Nektar::LocalRegions::SegExpSharedPtr Exp =
749 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
750 basisKeyDir1, segGeom.get());
751
752 int nelmts = 10;
753
754 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
755 for (int i = 0; i < nelmts; ++i)
756 {
757 CollExp.push_back(Exp);
758 }
759
760 LibUtilities::SessionReaderSharedPtr dummySession;
761 Collections::CollectionOptimisation colOpt(dummySession, 1,
762 Collections::eIterPerExp);
763 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
764 Collections::Collection c(CollExp, impTypes);
765 c.Initialise(Collections::ePhysDeriv);
766
767 const int nq = Exp->GetTotPoints();
768 Array<OneD, NekDouble> xc(nq);
769 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
770 Array<OneD, NekDouble> diff1(nelmts * nq);
771 Array<OneD, NekDouble> diff2(nelmts * nq);
772
773 Exp->GetCoords(xc);
774
775 for (int i = 0; i < nq; ++i)
776 {
777 phys[i] = sin(xc[i]);
778 }
779 Exp->PhysDeriv(phys, diff1);
780
781 for (int i = 1; i < nelmts; ++i)
782 {
783 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
784 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq);
785 }
786
787 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
788
789 double epsilon = 1.0e-8;
790 for (int i = 0; i < diff1.size(); ++i)
791 {
792 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
793 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
794 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
795 }
796}
797
798BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_StdMat_UniformP)
799{
800 SpatialDomains::PointGeomUniquePtr v0(
801 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
802 SpatialDomains::PointGeomUniquePtr v1(
803 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
804
805 SpatialDomains::SegGeomUniquePtr segGeom =
806 CreateSegGeom(0, v0.get(), v1.get());
807
808 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
809 Nektar::LibUtilities::eGaussLobattoLegendre;
810 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
811 segPointsTypeDir1);
812 Nektar::LibUtilities::BasisType basisTypeDir1 =
813 Nektar::LibUtilities::eModified_A;
814 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
815 segPointsKeyDir1);
816
817 Nektar::LocalRegions::SegExpSharedPtr Exp =
818 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
819 basisKeyDir1, segGeom.get());
820
821 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
822 CollExp.push_back(Exp);
823
824 LibUtilities::SessionReaderSharedPtr dummySession;
825 Collections::CollectionOptimisation colOpt(dummySession, 1,
826 Collections::eStdMat);
827 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
828 Collections::Collection c(CollExp, impTypes);
829 c.Initialise(Collections::ePhysDeriv);
830
831 const int nq = Exp->GetTotPoints();
832 Array<OneD, NekDouble> xc(nq);
833 Array<OneD, NekDouble> phys(nq), tmp;
834 Array<OneD, NekDouble> diff1(nq);
835 Array<OneD, NekDouble> diff2(nq);
836
837 Exp->GetCoords(xc);
838
839 for (int i = 0; i < nq; ++i)
840 {
841 phys[i] = sin(xc[i]);
842 }
843
844 Exp->PhysDeriv(phys, diff1);
845 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
846
847 double epsilon = 1.0e-8;
848 for (int i = 0; i < diff1.size(); ++i)
849 {
850 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
851 }
852}
853
854BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_StdMat_UniformP_MultiElmt)
855{
856 SpatialDomains::PointGeomUniquePtr v0(
857 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
858 SpatialDomains::PointGeomUniquePtr v1(
859 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
860
861 SpatialDomains::SegGeomUniquePtr segGeom =
862 CreateSegGeom(0, v0.get(), v1.get());
863
864 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
865 Nektar::LibUtilities::eGaussLobattoLegendre;
866 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
867 segPointsTypeDir1);
868 Nektar::LibUtilities::BasisType basisTypeDir1 =
869 Nektar::LibUtilities::eModified_A;
870 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
871 segPointsKeyDir1);
872
873 Nektar::LocalRegions::SegExpSharedPtr Exp =
874 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
875 basisKeyDir1, segGeom.get());
876
877 int nelmts = 10;
878
879 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
880 for (int i = 0; i < nelmts; ++i)
881 {
882 CollExp.push_back(Exp);
883 }
884
885 LibUtilities::SessionReaderSharedPtr dummySession;
886 Collections::CollectionOptimisation colOpt(dummySession, 1,
887 Collections::eStdMat);
888 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
889 Collections::Collection c(CollExp, impTypes);
890 c.Initialise(Collections::ePhysDeriv);
891
892 const int nq = Exp->GetTotPoints();
893 Array<OneD, NekDouble> xc(nq);
894 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
895 Array<OneD, NekDouble> diff1(nelmts * nq);
896 Array<OneD, NekDouble> diff2(nelmts * nq);
897
898 Exp->GetCoords(xc);
899
900 for (int i = 0; i < nq; ++i)
901 {
902 phys[i] = sin(xc[i]);
903 }
904 Exp->PhysDeriv(phys, diff1);
905
906 for (int i = 1; i < nelmts; ++i)
907 {
908 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
909 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq);
910 }
911
912 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
913
914 double epsilon = 1.0e-8;
915 for (int i = 0; i < diff1.size(); ++i)
916 {
917 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
918 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
919 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
920 }
921}
922
923BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_SumFac_UniformP_MultiElmt)
924{
925 SpatialDomains::PointGeomUniquePtr v0(
926 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
927 SpatialDomains::PointGeomUniquePtr v1(
928 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
929
930 SpatialDomains::SegGeomUniquePtr segGeom =
931 CreateSegGeom(0, v0.get(), v1.get());
932
933 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
934 Nektar::LibUtilities::eGaussLobattoLegendre;
935 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
936 segPointsTypeDir1);
937 Nektar::LibUtilities::BasisType basisTypeDir1 =
938 Nektar::LibUtilities::eModified_A;
939 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
940 segPointsKeyDir1);
941
942 Nektar::LocalRegions::SegExpSharedPtr Exp =
943 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
944 basisKeyDir1, segGeom.get());
945
946 int nelmts = 10;
947
948 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
949 for (int i = 0; i < nelmts; ++i)
950 {
951 CollExp.push_back(Exp);
952 }
953
954 LibUtilities::SessionReaderSharedPtr dummySession;
955 Collections::CollectionOptimisation colOpt(dummySession, 1,
956 Collections::eSumFac);
957 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
958 Collections::Collection c(CollExp, impTypes);
959 c.Initialise(Collections::ePhysDeriv);
960
961 const int nq = Exp->GetTotPoints();
962 Array<OneD, NekDouble> xc(nq);
963 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
964 Array<OneD, NekDouble> diff1(nelmts * nq);
965 Array<OneD, NekDouble> diff2(nelmts * nq);
966
967 Exp->GetCoords(xc);
968
969 for (int i = 0; i < nq; ++i)
970 {
971 phys[i] = sin(xc[i]);
972 }
973 Exp->PhysDeriv(phys, diff1);
974
975 for (int i = 1; i < nelmts; ++i)
976 {
977 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
978 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq);
979 }
980
981 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
982
983 double epsilon = 1.0e-8;
984 for (int i = 0; i < diff1.size(); ++i)
985 {
986 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
987 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
988 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
989 }
990}
991
992BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_MatrixFree_UniformP_MultiElmt_1D)
993{
994 SpatialDomains::PointGeomUniquePtr v0(
995 new SpatialDomains::PointGeom(1u, 0u, -1.5, 0.0, 0.0));
996 SpatialDomains::PointGeomUniquePtr v1(
997 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
998
999 SpatialDomains::SegGeomUniquePtr segGeom =
1000 CreateSegGeom(0, v0.get(), v1.get());
1001
1002 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1003 Nektar::LibUtilities::eGaussLobattoLegendre;
1004 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
1005 segPointsTypeDir1);
1006 Nektar::LibUtilities::BasisType basisTypeDir1 =
1007 Nektar::LibUtilities::eModified_A;
1008 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1009 segPointsKeyDir1);
1010
1011 Nektar::LocalRegions::SegExpSharedPtr Exp =
1012 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1013 basisKeyDir1, segGeom.get());
1014
1015 int nelmts = 10;
1016
1017 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1018 for (int i = 0; i < nelmts; ++i)
1019 {
1020 CollExp.push_back(Exp);
1021 }
1022
1023 LibUtilities::SessionReaderSharedPtr dummySession;
1024 Collections::CollectionOptimisation colOpt(dummySession, 1,
1025 Collections::eIterPerExp);
1026 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1027 impTypes[Collections::ePhysDeriv] = Collections::eMatrixFree;
1028 Collections::Collection c(CollExp, impTypes);
1029 c.Initialise(Collections::ePhysDeriv);
1030
1031 const int nq = Exp->GetTotPoints();
1032 Array<OneD, NekDouble> xc(nq);
1033 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
1034 Array<OneD, NekDouble> diff1(nelmts * nq);
1035 Array<OneD, NekDouble> diff2(nelmts * nq);
1036
1037 Exp->GetCoords(xc);
1038
1039 for (int i = 0; i < nq; ++i)
1040 {
1041 phys[i] = sin(xc[i]);
1042 }
1043 Exp->PhysDeriv(phys, diff1);
1044
1045 for (int i = 1; i < nelmts; ++i)
1046 {
1047 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
1048 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq);
1049 }
1050
1051 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2);
1052
1053 double epsilon = 1.0e-8;
1054 for (int i = 0; i < diff1.size(); ++i)
1055 {
1056 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
1057 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
1058 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
1059 }
1060}
1061
1062BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_MatrixFree_UniformP_MultiElmt_2D)
1063{
1064 SpatialDomains::PointGeomUniquePtr v0(
1065 new SpatialDomains::PointGeom(2u, 0u, -1.5, 0.0, 0.0));
1066 SpatialDomains::PointGeomUniquePtr v1(
1067 new SpatialDomains::PointGeom(2u, 1u, 1.0, 1.0, 0.0));
1068
1069 SpatialDomains::SegGeomUniquePtr segGeom =
1070 CreateSegGeom(0, v0.get(), v1.get(), 2u);
1071
1072 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1073 Nektar::LibUtilities::eGaussLobattoLegendre;
1074 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
1075 segPointsTypeDir1);
1076 Nektar::LibUtilities::BasisType basisTypeDir1 =
1077 Nektar::LibUtilities::eModified_A;
1078 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1079 segPointsKeyDir1);
1080
1081 Nektar::LocalRegions::SegExpSharedPtr Exp =
1082 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1083 basisKeyDir1, segGeom.get());
1084
1085 int nelmts = 10;
1086
1087 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1088 for (int i = 0; i < nelmts; ++i)
1089 {
1090 CollExp.push_back(Exp);
1091 }
1092
1093 LibUtilities::SessionReaderSharedPtr dummySession;
1094 Collections::CollectionOptimisation colOpt(dummySession, 1,
1095 Collections::eIterPerExp);
1096 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1097 impTypes[Collections::ePhysDeriv] = Collections::eMatrixFree;
1098 Collections::Collection c(CollExp, impTypes);
1099 c.Initialise(Collections::ePhysDeriv);
1100
1101 const int nq = Exp->GetTotPoints();
1102 Array<OneD, NekDouble> xc(nq), yc(nq);
1103 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1;
1104 Array<OneD, NekDouble> diff1(2 * nelmts * nq);
1105 Array<OneD, NekDouble> diff2(2 * nelmts * nq);
1106
1107 Exp->GetCoords(xc, yc);
1108
1109 for (int i = 0; i < nq; ++i)
1110 {
1111 phys[i] = sin(xc[i]) * cos(yc[i]);
1112 }
1113 Exp->PhysDeriv(phys, diff1, tmp = diff1 + nelmts * nq);
1114
1115 for (int i = 1; i < nelmts; ++i)
1116 {
1117 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
1118 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq,
1119 tmp1 = diff1 + (nelmts + i) * nq);
1120 }
1121
1122 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
1123 tmp = diff2 + nelmts * nq);
1124
1125 double epsilon = 1.0e-8;
1126 for (int i = 0; i < diff1.size(); ++i)
1127 {
1128 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
1129 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
1130 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
1131 }
1132}
1133
1134BOOST_AUTO_TEST_CASE(TestSegPhysDeriv_MatrixFree_UniformP_MultiElmt_3D)
1135{
1136 SpatialDomains::PointGeomUniquePtr v0(
1137 new SpatialDomains::PointGeom(3u, 0u, -1.5, 0.0, 0.0));
1138 SpatialDomains::PointGeomUniquePtr v1(
1139 new SpatialDomains::PointGeom(3u, 1u, 1.0, 1.0, 1.0));
1140
1141 SpatialDomains::SegGeomUniquePtr segGeom =
1142 CreateSegGeom(0, v0.get(), v1.get(), 3u);
1143
1144 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1145 Nektar::LibUtilities::eGaussLobattoLegendre;
1146 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(5,
1147 segPointsTypeDir1);
1148 Nektar::LibUtilities::BasisType basisTypeDir1 =
1149 Nektar::LibUtilities::eModified_A;
1150 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1151 segPointsKeyDir1);
1152
1153 Nektar::LocalRegions::SegExpSharedPtr Exp =
1154 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1155 basisKeyDir1, segGeom.get());
1156
1157 int nelmts = 10;
1158
1159 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1160 for (int i = 0; i < nelmts; ++i)
1161 {
1162 CollExp.push_back(Exp);
1163 }
1164
1165 LibUtilities::SessionReaderSharedPtr dummySession;
1166 Collections::CollectionOptimisation colOpt(dummySession, 1,
1167 Collections::eIterPerExp);
1168 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1169 impTypes[Collections::ePhysDeriv] = Collections::eMatrixFree;
1170 Collections::Collection c(CollExp, impTypes);
1171 c.Initialise(Collections::ePhysDeriv);
1172
1173 const int nq = Exp->GetTotPoints();
1174 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1175 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1, tmp2;
1176 Array<OneD, NekDouble> diff1(3 * nelmts * nq);
1177 Array<OneD, NekDouble> diff2(3 * nelmts * nq);
1178
1179 Exp->GetCoords(xc, yc, zc);
1180
1181 for (int i = 0; i < nq; ++i)
1182 {
1183 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1184 }
1185 Exp->PhysDeriv(phys, diff1, tmp = diff1 + nelmts * nq,
1186 tmp1 = diff1 + 2 * nelmts * nq);
1187
1188 for (int i = 1; i < nelmts; ++i)
1189 {
1190 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
1191 Exp->PhysDeriv(phys + i * nq, tmp = diff1 + i * nq,
1192 tmp1 = diff1 + (nelmts + i) * nq,
1193 tmp2 = diff1 + (2 * nelmts + i) * nq);
1194 }
1195
1196 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
1197 tmp = diff2 + nelmts * nq, tmp1 = diff2 + 2 * nelmts * nq);
1198
1199 double epsilon = 1.0e-8;
1200 for (int i = 0; i < diff1.size(); ++i)
1201 {
1202 diff1[i] = (fabs(diff1[i]) < 1e-14) ? 0.0 : diff1[i];
1203 diff2[i] = (fabs(diff2[i]) < 1e-14) ? 0.0 : diff2[i];
1204 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
1205 }
1206}
1207
1208BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_IterPerExp_UniformP)
1209{
1210 SpatialDomains::PointGeomUniquePtr v0(
1211 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1212 SpatialDomains::PointGeomUniquePtr v1(
1213 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1214
1215 SpatialDomains::SegGeomUniquePtr segGeom =
1216 CreateSegGeom(0, v0.get(), v1.get());
1217
1218 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1219 Nektar::LibUtilities::eGaussLobattoLegendre;
1220 Nektar::LibUtilities::BasisType basisTypeDir1 =
1221 Nektar::LibUtilities::eModified_A;
1222 unsigned int numSegPoints = 6;
1223 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1224 segPointsTypeDir1);
1225 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1226 segPointsKeyDir1);
1227
1228 Nektar::LocalRegions::SegExpSharedPtr Exp =
1229 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1230 basisKeyDir1, segGeom.get());
1231
1232 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1233 CollExp.push_back(Exp);
1234
1235 LibUtilities::SessionReaderSharedPtr dummySession;
1236 Collections::CollectionOptimisation colOpt(dummySession, 1,
1237 Collections::eIterPerExp);
1238 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1239 Collections::Collection c(CollExp, impTypes);
1240 c.Initialise(Collections::eIProductWRTDerivBase);
1241
1242 const int nq = Exp->GetTotPoints();
1243 const int nm = Exp->GetNcoeffs();
1244 Array<OneD, NekDouble> phys1(nq);
1245 Array<OneD, NekDouble> coeffs1(nm);
1246 Array<OneD, NekDouble> coeffs2(nm);
1247
1248 Array<OneD, NekDouble> xc(nq);
1249
1250 Exp->GetCoords(xc);
1251
1252 for (int i = 0; i < nq; ++i)
1253 {
1254 phys1[i] = sin(xc[i]);
1255 }
1256
1257 // Standard routines
1258 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1259
1260 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1261
1262 double epsilon = 1.0e-8;
1263 for (int i = 0; i < coeffs1.size(); ++i)
1264 {
1265 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1266 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1267 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1268 }
1269}
1270
1271BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_IterPerExp_UniformP_MultiElmt)
1272{
1273 SpatialDomains::PointGeomUniquePtr v0(
1274 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1275 SpatialDomains::PointGeomUniquePtr v1(
1276 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1277
1278 SpatialDomains::SegGeomUniquePtr segGeom =
1279 CreateSegGeom(0, v0.get(), v1.get());
1280
1281 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1282 Nektar::LibUtilities::eGaussLobattoLegendre;
1283 Nektar::LibUtilities::BasisType basisTypeDir1 =
1284 Nektar::LibUtilities::eModified_A;
1285 unsigned int numSegPoints = 6;
1286 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1287 segPointsTypeDir1);
1288 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1289 segPointsKeyDir1);
1290
1291 Nektar::LocalRegions::SegExpSharedPtr Exp =
1292 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1293 basisKeyDir1, segGeom.get());
1294
1295 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1296
1297 int nelmts = 10;
1298 for (int i = 0; i < nelmts; ++i)
1299 {
1300 CollExp.push_back(Exp);
1301 }
1302
1303 LibUtilities::SessionReaderSharedPtr dummySession;
1304 Collections::CollectionOptimisation colOpt(dummySession, 1,
1305 Collections::eIterPerExp);
1306 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1307 Collections::Collection c(CollExp, impTypes);
1308 c.Initialise(Collections::eIProductWRTDerivBase);
1309
1310 const int nq = Exp->GetTotPoints();
1311 const int nm = Exp->GetNcoeffs();
1312 Array<OneD, NekDouble> xc(nq), tmp, tmp1;
1313 Array<OneD, NekDouble> phys1(nelmts * nq);
1314 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1315 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1316
1317 Exp->GetCoords(xc);
1318
1319 for (int i = 0; i < nq; ++i)
1320 {
1321 phys1[i] = sin(xc[i]);
1322 }
1323 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1324
1325 for (int i = 1; i < nelmts; ++i)
1326 {
1327 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1328
1329 // Standard routines
1330 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1331 }
1332
1333 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1334
1335 double epsilon = 1.0e-8;
1336 for (int i = 0; i < coeffs1.size(); ++i)
1337 {
1338 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1339 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1340 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1341 }
1342}
1343
1344BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_StdMat_UniformP)
1345{
1346 SpatialDomains::PointGeomUniquePtr v0(
1347 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1348 SpatialDomains::PointGeomUniquePtr v1(
1349 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1350
1351 SpatialDomains::SegGeomUniquePtr segGeom =
1352 CreateSegGeom(0, v0.get(), v1.get());
1353
1354 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1355 Nektar::LibUtilities::eGaussLobattoLegendre;
1356 Nektar::LibUtilities::BasisType basisTypeDir1 =
1357 Nektar::LibUtilities::eModified_A;
1358 unsigned int numSegPoints = 6;
1359 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1360 segPointsTypeDir1);
1361 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1362 segPointsKeyDir1);
1363
1364 Nektar::LocalRegions::SegExpSharedPtr Exp =
1365 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1366 basisKeyDir1, segGeom.get());
1367
1368 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1369 CollExp.push_back(Exp);
1370
1371 LibUtilities::SessionReaderSharedPtr dummySession;
1372 Collections::CollectionOptimisation colOpt(dummySession, 1,
1373 Collections::eStdMat);
1374 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1375 Collections::Collection c(CollExp, impTypes);
1376 c.Initialise(Collections::eIProductWRTDerivBase);
1377
1378 const int nq = Exp->GetTotPoints();
1379 const int nm = Exp->GetNcoeffs();
1380 Array<OneD, NekDouble> phys1(nq);
1381 Array<OneD, NekDouble> coeffs1(nm);
1382 Array<OneD, NekDouble> coeffs2(nm);
1383
1384 Array<OneD, NekDouble> xc(nq);
1385
1386 Exp->GetCoords(xc);
1387
1388 for (int i = 0; i < nq; ++i)
1389 {
1390 phys1[i] = sin(xc[i]);
1391 }
1392
1393 // Standard routines
1394 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1395
1396 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1397
1398 double epsilon = 1.0e-8;
1399 for (int i = 0; i < coeffs1.size(); ++i)
1400 {
1401 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1402 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1403 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1404 }
1405}
1406
1407BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_StdMat_UniformP_MultiElmt)
1408{
1409 SpatialDomains::PointGeomUniquePtr v0(
1410 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1411 SpatialDomains::PointGeomUniquePtr v1(
1412 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1413
1414 SpatialDomains::SegGeomUniquePtr segGeom =
1415 CreateSegGeom(0, v0.get(), v1.get());
1416
1417 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1418 Nektar::LibUtilities::eGaussLobattoLegendre;
1419 Nektar::LibUtilities::BasisType basisTypeDir1 =
1420 Nektar::LibUtilities::eModified_A;
1421 unsigned int numSegPoints = 6;
1422 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1423 segPointsTypeDir1);
1424 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1425 segPointsKeyDir1);
1426
1427 Nektar::LocalRegions::SegExpSharedPtr Exp =
1428 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1429 basisKeyDir1, segGeom.get());
1430
1431 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1432
1433 int nelmts = 10;
1434 for (int i = 0; i < nelmts; ++i)
1435 {
1436 CollExp.push_back(Exp);
1437 }
1438
1439 LibUtilities::SessionReaderSharedPtr dummySession;
1440 Collections::CollectionOptimisation colOpt(dummySession, 1,
1441 Collections::eStdMat);
1442 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1443 Collections::Collection c(CollExp, impTypes);
1444 c.Initialise(Collections::eIProductWRTDerivBase);
1445
1446 const int nq = Exp->GetTotPoints();
1447 const int nm = Exp->GetNcoeffs();
1448 Array<OneD, NekDouble> xc(nq), tmp, tmp1;
1449 Array<OneD, NekDouble> phys1(nelmts * nq);
1450 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1451 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1452
1453 Exp->GetCoords(xc);
1454
1455 for (int i = 0; i < nq; ++i)
1456 {
1457 phys1[i] = sin(xc[i]);
1458 }
1459 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1460
1461 for (int i = 1; i < nelmts; ++i)
1462 {
1463 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1464
1465 // Standard routines
1466 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1467 }
1468
1469 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1470
1471 double epsilon = 1.0e-8;
1472 for (int i = 0; i < coeffs1.size(); ++i)
1473 {
1474 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1475 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1476 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1477 }
1478}
1479
1480BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_SumFac_UniformP)
1481{
1482 SpatialDomains::PointGeomUniquePtr v0(
1483 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1484 SpatialDomains::PointGeomUniquePtr v1(
1485 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1486
1487 SpatialDomains::SegGeomUniquePtr segGeom =
1488 CreateSegGeom(0, v0.get(), v1.get());
1489
1490 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1491 Nektar::LibUtilities::eGaussLobattoLegendre;
1492 Nektar::LibUtilities::BasisType basisTypeDir1 =
1493 Nektar::LibUtilities::eModified_A;
1494 unsigned int numSegPoints = 6;
1495 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1496 segPointsTypeDir1);
1497 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1498 segPointsKeyDir1);
1499
1500 Nektar::LocalRegions::SegExpSharedPtr Exp =
1501 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1502 basisKeyDir1, segGeom.get());
1503
1504 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1505 CollExp.push_back(Exp);
1506
1507 LibUtilities::SessionReaderSharedPtr dummySession;
1508 Collections::CollectionOptimisation colOpt(dummySession, 1,
1509 Collections::eSumFac);
1510 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1511 Collections::Collection c(CollExp, impTypes);
1512 c.Initialise(Collections::eIProductWRTDerivBase);
1513
1514 const int nq = Exp->GetTotPoints();
1515 const int nm = Exp->GetNcoeffs();
1516 Array<OneD, NekDouble> phys1(nq);
1517 Array<OneD, NekDouble> coeffs1(nm);
1518 Array<OneD, NekDouble> coeffs2(nm);
1519
1520 Array<OneD, NekDouble> xc(nq);
1521
1522 Exp->GetCoords(xc);
1523
1524 for (int i = 0; i < nq; ++i)
1525 {
1526 phys1[i] = sin(xc[i]);
1527 }
1528
1529 // Standard routines
1530 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1531
1532 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1533
1534 double epsilon = 1.0e-8;
1535 for (int i = 0; i < coeffs1.size(); ++i)
1536 {
1537 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1538 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1539 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1540 }
1541}
1542
1543BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_SumFac_UniformP_MultiElmt)
1544{
1545 SpatialDomains::PointGeomUniquePtr v0(
1546 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1547 SpatialDomains::PointGeomUniquePtr v1(
1548 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1549
1550 SpatialDomains::SegGeomUniquePtr segGeom =
1551 CreateSegGeom(0, v0.get(), v1.get());
1552
1553 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1554 Nektar::LibUtilities::eGaussLobattoLegendre;
1555 Nektar::LibUtilities::BasisType basisTypeDir1 =
1556 Nektar::LibUtilities::eModified_A;
1557 unsigned int numSegPoints = 6;
1558 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1559 segPointsTypeDir1);
1560 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1561 segPointsKeyDir1);
1562
1563 Nektar::LocalRegions::SegExpSharedPtr Exp =
1564 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1565 basisKeyDir1, segGeom.get());
1566
1567 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1568
1569 int nelmts = 10;
1570 for (int i = 0; i < nelmts; ++i)
1571 {
1572 CollExp.push_back(Exp);
1573 }
1574
1575 LibUtilities::SessionReaderSharedPtr dummySession;
1576 Collections::CollectionOptimisation colOpt(dummySession, 1,
1577 Collections::eSumFac);
1578 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1579 Collections::Collection c(CollExp, impTypes);
1580 c.Initialise(Collections::eIProductWRTDerivBase);
1581
1582 const int nq = Exp->GetTotPoints();
1583 const int nm = Exp->GetNcoeffs();
1584 Array<OneD, NekDouble> xc(nq), tmp, tmp1;
1585 Array<OneD, NekDouble> phys1(nelmts * nq);
1586 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1587 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1588
1589 Exp->GetCoords(xc);
1590
1591 for (int i = 0; i < nq; ++i)
1592 {
1593 phys1[i] = sin(xc[i]);
1594 }
1595 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1596
1597 for (int i = 1; i < nelmts; ++i)
1598 {
1599 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1600
1601 // Standard routines
1602 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1603 }
1604
1605 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1606
1607 double epsilon = 1.0e-8;
1608 for (int i = 0; i < coeffs1.size(); ++i)
1609 {
1610 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1611 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1612 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1613 }
1614}
1615
1616BOOST_AUTO_TEST_CASE(
1617 TestSegIProductWRTDerivBase_SumFac_UniformP_MultiElmt_CoordimTwo)
1618{
1619 SpatialDomains::PointGeomUniquePtr v0(
1620 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1621 SpatialDomains::PointGeomUniquePtr v1(
1622 new SpatialDomains::PointGeom(1u, 1u, 1.0, 1.0, 0.0));
1623
1624 SpatialDomains::SegGeomUniquePtr segGeom =
1625 CreateSegGeom(0, v0.get(), v1.get(), 2);
1626
1627 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1628 Nektar::LibUtilities::eGaussLobattoLegendre;
1629 Nektar::LibUtilities::BasisType basisTypeDir1 =
1630 Nektar::LibUtilities::eModified_A;
1631 unsigned int numSegPoints = 6;
1632 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1633 segPointsTypeDir1);
1634 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1635 segPointsKeyDir1);
1636
1637 Nektar::LocalRegions::SegExpSharedPtr Exp =
1638 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1639 basisKeyDir1, segGeom.get());
1640
1641 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1642
1643 int nelmts = 10;
1644 for (int i = 0; i < nelmts; ++i)
1645 {
1646 CollExp.push_back(Exp);
1647 }
1648
1649 LibUtilities::SessionReaderSharedPtr dummySession;
1650 Collections::CollectionOptimisation colOpt(dummySession, 1,
1651 Collections::eSumFac);
1652 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1653 Collections::Collection c(CollExp, impTypes);
1654 c.Initialise(Collections::eIProductWRTDerivBase);
1655
1656 const int nq = Exp->GetTotPoints();
1657 const int nm = Exp->GetNcoeffs();
1658 Array<OneD, NekDouble> xc(nq), yc(nq), tmp, tmp1;
1659 Array<OneD, NekDouble> phys1(nelmts * nq);
1660 Array<OneD, NekDouble> phys2(nelmts * nq);
1661 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1662 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1663
1664 Exp->GetCoords(xc, yc);
1665
1666 for (int i = 0; i < nq; ++i)
1667 {
1668 phys1[i] = sin(xc[i]);
1669 phys2[i] = cos(yc[i]);
1670 }
1671 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1672 Exp->IProductWRTDerivBase(1, phys2, coeffs2);
1673
1674 for (int i = 1; i < nelmts; ++i)
1675 {
1676 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1677 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
1678
1679 // Standard routines
1680 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1681 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
1682 }
1683 Vmath::Vadd(nelmts * nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
1684
1685 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, coeffs2);
1686
1687 double epsilon = 1.0e-8;
1688 for (int i = 0; i < coeffs1.size(); ++i)
1689 {
1690 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1691 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1692 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1693 }
1694}
1695
1696BOOST_AUTO_TEST_CASE(TestSegIProductWRTDerivBase_MatrixFree_UniformP_MultiElmt)
1697{
1698 SpatialDomains::PointGeomUniquePtr v0(
1699 new SpatialDomains::PointGeom(1u, 0u, -1.0, 0.0, 0.0));
1700 SpatialDomains::PointGeomUniquePtr v1(
1701 new SpatialDomains::PointGeom(1u, 1u, 1.0, 0.0, 0.0));
1702
1703 SpatialDomains::SegGeomUniquePtr segGeom =
1704 CreateSegGeom(0, v0.get(), v1.get());
1705
1706 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1707 Nektar::LibUtilities::eGaussLobattoLegendre;
1708 Nektar::LibUtilities::BasisType basisTypeDir1 =
1709 Nektar::LibUtilities::eModified_A;
1710 unsigned int numSegPoints = 6;
1711 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1712 segPointsTypeDir1);
1713 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1714 segPointsKeyDir1);
1715
1716 Nektar::LocalRegions::SegExpSharedPtr Exp =
1717 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1718 basisKeyDir1, segGeom.get());
1719
1720 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1721
1722 int nelmts = 10;
1723 for (int i = 0; i < nelmts; ++i)
1724 {
1725 CollExp.push_back(Exp);
1726 }
1727
1728 LibUtilities::SessionReaderSharedPtr dummySession;
1729 Collections::CollectionOptimisation colOpt(dummySession, 1,
1730 Collections::eIterPerExp);
1731 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1732 impTypes[Collections::eIProductWRTDerivBase] = Collections::eMatrixFree;
1733 Collections::Collection c(CollExp, impTypes);
1734 c.Initialise(Collections::eIProductWRTDerivBase);
1735
1736 const int nq = Exp->GetTotPoints();
1737 const int nm = Exp->GetNcoeffs();
1738 Array<OneD, NekDouble> xc(nq), tmp, tmp1;
1739 Array<OneD, NekDouble> phys1(nelmts * nq);
1740 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1741 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1742
1743 Exp->GetCoords(xc);
1744
1745 for (int i = 0; i < nq; ++i)
1746 {
1747 phys1[i] = sin(xc[i]);
1748 }
1749 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1750
1751 for (int i = 1; i < nelmts; ++i)
1752 {
1753 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1754
1755 // Standard routines
1756 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1757 }
1758
1759 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, coeffs2);
1760
1761 double epsilon = 1.0e-8;
1762 for (int i = 0; i < coeffs1.size(); ++i)
1763 {
1764 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1765 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1766 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1767 }
1768}
1769
1770BOOST_AUTO_TEST_CASE(
1771 TestSegIProductWRTDerivBase_MatrixFree_UniformP_MultiElmt_CoordimTwo)
1772{
1773 SpatialDomains::PointGeomUniquePtr v0(
1774 new SpatialDomains::PointGeom(2u, 0u, -1.0, 0.0, 0.0));
1775 SpatialDomains::PointGeomUniquePtr v1(
1776 new SpatialDomains::PointGeom(2u, 1u, 1.0, 1.0, 0.0));
1777
1778 SpatialDomains::SegGeomUniquePtr segGeom =
1779 CreateSegGeom(0, v0.get(), v1.get(), 2);
1780
1781 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1782 Nektar::LibUtilities::eGaussLobattoLegendre;
1783 Nektar::LibUtilities::BasisType basisTypeDir1 =
1784 Nektar::LibUtilities::eModified_A;
1785 unsigned int numSegPoints = 6;
1786 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1787 segPointsTypeDir1);
1788 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1789 segPointsKeyDir1);
1790
1791 Nektar::LocalRegions::SegExpSharedPtr Exp =
1792 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1793 basisKeyDir1, segGeom.get());
1794
1795 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1796
1797 int nelmts = 10;
1798 for (int i = 0; i < nelmts; ++i)
1799 {
1800 CollExp.push_back(Exp);
1801 }
1802
1803 LibUtilities::SessionReaderSharedPtr dummySession;
1804 Collections::CollectionOptimisation colOpt(dummySession, 1,
1805 Collections::eIterPerExp);
1806 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1807 impTypes[Collections::eIProductWRTDerivBase] = Collections::eMatrixFree;
1808 Collections::Collection c(CollExp, impTypes);
1809 c.Initialise(Collections::eIProductWRTDerivBase);
1810
1811 const int nq = Exp->GetTotPoints();
1812 const int nm = Exp->GetNcoeffs();
1813 Array<OneD, NekDouble> xc(nq), yc(nq), tmp, tmp1;
1814 Array<OneD, NekDouble> phys1(nelmts * nq);
1815 Array<OneD, NekDouble> phys2(nelmts * nq);
1816 Array<OneD, NekDouble> coeffs1(nelmts * nm);
1817 Array<OneD, NekDouble> coeffs2(nelmts * nm);
1818
1819 Exp->GetCoords(xc, yc);
1820
1821 for (int i = 0; i < nq; ++i)
1822 {
1823 phys1[i] = sin(xc[i]);
1824 phys2[i] = cos(yc[i]);
1825 }
1826 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
1827 Exp->IProductWRTDerivBase(1, phys2, coeffs2);
1828
1829 for (int i = 1; i < nelmts; ++i)
1830 {
1831 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
1832 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
1833
1834 // Standard routines
1835 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
1836 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
1837 }
1838 Vmath::Vadd(nelmts * nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
1839
1840 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, coeffs2);
1841
1842 double epsilon = 1.0e-8;
1843 for (int i = 0; i < coeffs1.size(); ++i)
1844 {
1845 coeffs1[i] = (fabs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
1846 coeffs2[i] = (fabs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
1847 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1848 }
1849}
1850
1851BOOST_AUTO_TEST_CASE(TestSegPhysInterp1D_NoCollection_UniformP)
1852{
1853 SpatialDomains::PointGeomUniquePtr v0(
1854 new SpatialDomains::PointGeom(2u, 0u, -1.0, 0.0, 0.0));
1855 SpatialDomains::PointGeomUniquePtr v1(
1856 new SpatialDomains::PointGeom(2u, 1u, 1.0, 0.0, 0.0));
1857
1858 SpatialDomains::SegGeomUniquePtr segGeom =
1859 CreateSegGeom(0, v0.get(), v1.get(), 2);
1860
1861 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1862 Nektar::LibUtilities::eGaussLobattoLegendre;
1863 Nektar::LibUtilities::BasisType basisTypeDir1 =
1864 Nektar::LibUtilities::eModified_A;
1865 unsigned int numSegPoints = 6;
1866 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1867 segPointsTypeDir1);
1868 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1869 segPointsKeyDir1);
1870
1871 Nektar::LocalRegions::SegExpSharedPtr Exp =
1872 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1873 basisKeyDir1, segGeom.get());
1874
1875 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1876 CollExp.push_back(Exp);
1877
1878 LibUtilities::SessionReaderSharedPtr dummySession;
1879 Collections::CollectionOptimisation colOpt(dummySession, 1,
1880 Collections::eNoCollection);
1881 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1882 Collections::Collection c(CollExp, impTypes);
1883
1884 StdRegions::ConstFactorMap factors;
1885 factors[StdRegions::eFactorConst] = 1.5;
1886 c.Initialise(Collections::ePhysInterp1DScaled, factors);
1887
1888 const int nq = Exp->GetTotPoints();
1889
1890 Array<OneD, NekDouble> xc(nq), yc(nq);
1891 Array<OneD, NekDouble> phys(nq), tmp;
1892
1893 Exp->GetCoords(xc, yc);
1894
1895 for (int i = 0; i < nq; ++i)
1896 {
1897 phys[i] = pow(xc[i], 3) + pow(yc[i], 3);
1898 }
1899
1900 const int nq1 = c.GetOutputSize(Collections::ePhysInterp1DScaled);
1901 Array<OneD, NekDouble> xc1(nq1);
1902 Array<OneD, NekDouble> yc1(nq1);
1903 Array<OneD, NekDouble> phys1(nq1);
1904
1905 c.ApplyOperator(Collections::ePhysInterp1DScaled, xc, xc1);
1906 c.ApplyOperator(Collections::ePhysInterp1DScaled, yc, yc1);
1907 c.ApplyOperator(Collections::ePhysInterp1DScaled, phys, phys1);
1908
1909 double epsilon = 1.0e-8;
1910 // since solution is a polynomial should be able to compare soln directly
1911 for (int i = 0; i < nq1; ++i)
1912 {
1913 NekDouble exact = pow(xc1[i], 3) + pow(yc1[i], 3);
1914 phys1[i] = (fabs(phys1[i]) < 1e-14) ? 0.0 : phys1[i];
1915 exact = (fabs(exact) < 1e-14) ? 0.0 : exact;
1916 BOOST_CHECK_CLOSE(phys1[i], exact, epsilon);
1917 }
1918}
1919
1920BOOST_AUTO_TEST_CASE(TestSegPhysInterp1D_MatrixFree_UniformP)
1921{
1922 SpatialDomains::PointGeomUniquePtr v0(
1923 new SpatialDomains::PointGeom(2u, 0u, -1.0, 1.0, 0.0));
1924 SpatialDomains::PointGeomUniquePtr v1(
1925 new SpatialDomains::PointGeom(2u, 1u, 1.0, 1.0, 0.0));
1926
1927 SpatialDomains::SegGeomUniquePtr segGeom =
1928 CreateSegGeom(0, v0.get(), v1.get(), 2);
1929
1930 Nektar::LibUtilities::PointsType segPointsTypeDir1 =
1931 Nektar::LibUtilities::eGaussLobattoLegendre;
1932 Nektar::LibUtilities::BasisType basisTypeDir1 =
1933 Nektar::LibUtilities::eModified_A;
1934 unsigned int numSegPoints = 6;
1935 const Nektar::LibUtilities::PointsKey segPointsKeyDir1(numSegPoints,
1936 segPointsTypeDir1);
1937 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1938 segPointsKeyDir1);
1939
1940 Nektar::LocalRegions::SegExpSharedPtr Exp =
1941 MemoryManager<Nektar::LocalRegions::SegExp>::AllocateSharedPtr(
1942 basisKeyDir1, segGeom.get());
1943
1944 std::vector<LocalRegions::ExpansionSharedPtr> CollExp;
1945 CollExp.push_back(Exp);
1946
1947 LibUtilities::SessionReaderSharedPtr dummySession;
1948 Collections::CollectionOptimisation colOpt(dummySession, 1,
1949 Collections::eMatrixFree);
1950 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
1951 Collections::Collection c(CollExp, impTypes);
1952
1953 StdRegions::ConstFactorMap factors;
1954 factors[StdRegions::eFactorConst] = 1.5;
1955 c.Initialise(Collections::ePhysInterp1DScaled, factors);
1956
1957 const int nq = Exp->GetTotPoints();
1958
1959 Array<OneD, NekDouble> xc(nq), yc(nq);
1960 Array<OneD, NekDouble> phys(nq), tmp;
1961
1962 Exp->GetCoords(xc, yc);
1963
1964 for (int i = 0; i < nq; ++i)
1965 {
1966 yc[i] = (fabs(yc[i]) < 1e-14) ? 0.0 : yc[i];
1967 phys[i] = pow(xc[i], 3) + pow(yc[i], 3);
1968 }
1969
1970 const int nq1 = c.GetOutputSize(Collections::ePhysInterp1DScaled);
1971 Array<OneD, NekDouble> xc1(nq1);
1972 Array<OneD, NekDouble> yc1(nq1);
1973 Array<OneD, NekDouble> phys1(nq1);
1974
1975 c.ApplyOperator(Collections::ePhysInterp1DScaled, xc, xc1);
1976 c.ApplyOperator(Collections::ePhysInterp1DScaled, yc, yc1);
1977 c.ApplyOperator(Collections::ePhysInterp1DScaled, phys, phys1);
1978
1979 double epsilon = 1.0e-8;
1980 // since solution is a polynomial should be able to compare soln directly
1981 for (int i = 0; i < nq1; ++i)
1982 {
1983 xc1[i] = (fabs(xc1[i]) < 1e-14) ? 0.0 : xc1[i];
1984 yc1[i] = (fabs(yc1[i]) < 1e-14) ? 0.0 : yc1[i];
1985 NekDouble exact = pow(xc1[i], 3) + pow(yc1[i], 3);
1986 phys1[i] = (fabs(phys1[i]) < 1e-14) ? 0.0 : phys1[i];
1987 exact = (fabs(exact) < 1e-14) ? 0.0 : exact;
1988 BOOST_CHECK_CLOSE(phys1[i], exact, epsilon);
1989 }
1990}
1991
1992} // namespace Nektar::SegCollectionTests
Nektar::Collections::Collection::GetOutputSize
int GetOutputSize(const OperatorType &op)
Definition Collection.h:112
Nektar::Collections::Collection::Initialise
COLLECTIONS_EXPORT void Initialise(const OperatorType opType, StdRegions::FactorMap factors=StdRegions::NullFactorMap)
Definition Collection.cpp:66
Nektar::Collections::Collection::ApplyOperator
void ApplyOperator(const OperatorType &op, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &output)
Definition Collection.h:148
Nektar::Collections::CollectionOptimisation::GetOperatorImpMap
COLLECTIONS_EXPORT OperatorImpMap GetOperatorImpMap(LocalRegions::ExpansionSharedPtr pExp)
Get Operator Implementation Map from XMl or using default;.
Definition CollectionOptimisation.cpp:356
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::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition NekMemoryManager.hpp:167
Nektar::Collections::OperatorImpMap
std::map< OperatorType, ImplementationType > OperatorImpMap
Definition Operator.h:131
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition SessionReader.h:119
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition PointsType.h:51
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition BasisType.h:48
Nektar::LocalRegions::SegExpSharedPtr
std::shared_ptr< SegExp > SegExpSharedPtr
Definition SegExp.h:208
Nektar::SegCollectionTests::CreateSegGeom
SpatialDomains::SegGeomUniquePtr CreateSegGeom(unsigned int id, SpatialDomains::PointGeom *v0, SpatialDomains::PointGeom *v1, int coordim=1)
Definition TestSegCollection.cpp:44
Nektar::SegCollectionTests::BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(TestSegBwdTrans_StdMat_UniformP)
Definition TestSegCollection.cpp:55
Nektar::SpatialDomains::SegGeomUniquePtr
unique_ptr_objpool< SegGeom > SegGeomUniquePtr
Definition MeshGraph.h:102
Nektar::SpatialDomains::PointGeomUniquePtr
unique_ptr_objpool< PointGeom > PointGeomUniquePtr
Definition MeshGraph.h:99
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition StdRegions.hpp:489
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition Vmath.hpp:180
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition Vmath.hpp:825
Generated on Sat Jul 4 2026 01:02:24 for Nektar++ by doxygen 1.9.8