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