Nektar++
Functions
Nektar::HexCollectionTests Namespace Reference

Functions

SpatialDomains::SegGeomSharedPtr CreateSegGeom (unsigned int id, SpatialDomains::PointGeomSharedPtr v0, SpatialDomains::PointGeomSharedPtr v1)
 
SpatialDomains::HexGeomSharedPtr CreateHex (SpatialDomains::PointGeomSharedPtr v0, SpatialDomains::PointGeomSharedPtr v1, SpatialDomains::PointGeomSharedPtr v2, SpatialDomains::PointGeomSharedPtr v3, SpatialDomains::PointGeomSharedPtr v4, SpatialDomains::PointGeomSharedPtr v5, SpatialDomains::PointGeomSharedPtr v6, SpatialDomains::PointGeomSharedPtr v7)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_StdMat_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_StdMat_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_IterPerExp_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_IterPerExp_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_IterPerExp_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_NoCollection_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_SumFac_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_SumFac_UniformP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_SumFac_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_SumFac_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexBwdTrans_MatrixFree_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_StdMat_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_MatrixFree_UniformP_Undeformed)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_MatrixFree_UniformP_Deformed)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_MatrixFree_UniformP_Deformed_OverInt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_StdMat_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_NoCollection_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_CollAll)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_CollDir02)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_CollDir12)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_StdMat_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_IterPerExp_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_UniformP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_MultiElmt_CollDir02)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTBase_SumFac_VariableP_MultiElmt_CollDir12)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_IterPerExp_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_MatrixFree_UniformP_Undeformed)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_MatrixFree_UniformP_Deformed)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_IterPerExp_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_NoCollection_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_StdMat_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_StdMat_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_SumFac_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexPhysDeriv_SumFac_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_Iterperexp_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_MatrixFree_UniformP_Undeformed)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_MatrixFree_UniformP_Deformed)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_MatrixFree_UniformP_Deformed_OverInt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_IterPerExp_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_StdMat_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_StdMat_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_NoCollection_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_SumFac_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexIProductWRTDerivBase_SumFac_VariableP_MultiElmt)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_NoCollection_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_IterPerExp_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_IterPerExp_UniformP_ConstVarDiff)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_MatrixFree_UniformP)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_MatrixFree_UniformP_Deformed_OverInt)
 
 BOOST_AUTO_TEST_CASE (TestHexHelmholtz_MatrixFree_UniformP_ConstVarDiff)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_IterPerExp_UniformP  )

Definition at line 243 of file TestHexCollection.cpp.

244{
245 SpatialDomains::PointGeomSharedPtr v0(
246 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
247 SpatialDomains::PointGeomSharedPtr v1(
248 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
249 SpatialDomains::PointGeomSharedPtr v2(
250 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
251 SpatialDomains::PointGeomSharedPtr v3(
252 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
253 SpatialDomains::PointGeomSharedPtr v4(
254 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
255 SpatialDomains::PointGeomSharedPtr v5(
256 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
257 SpatialDomains::PointGeomSharedPtr v6(
258 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
259 SpatialDomains::PointGeomSharedPtr v7(
260 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
261
262 SpatialDomains::HexGeomSharedPtr hexGeom =
263 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
264
265 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
266 Nektar::LibUtilities::eGaussLobattoLegendre;
267 Nektar::LibUtilities::BasisType basisTypeDir1 =
268 Nektar::LibUtilities::eModified_A;
269 unsigned int numQuadPoints = 6;
270 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
271 quadPointsTypeDir1);
272 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
273 quadPointsKeyDir1);
274
275 Nektar::LocalRegions::HexExpSharedPtr Exp =
276 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
277 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
278
279 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
280 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
281 basisKeyDir1, basisKeyDir1, basisKeyDir1);
282
283 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
284 CollExp.push_back(Exp);
285
286 LibUtilities::SessionReaderSharedPtr dummySession;
287 Collections::CollectionOptimisation colOpt(dummySession, 3,
288 Collections::eIterPerExp);
289 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
290 Collections::Collection c(CollExp, impTypes);
291 c.Initialise(Collections::eBwdTrans);
292
293 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
294 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
295 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
296
297 Exp->BwdTrans(coeffs, phys1);
298 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
299
300 double epsilon = 1.0e-8;
301 for (int i = 0; i < phys1.size(); ++i)
302 {
303 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
304 }
305}
Nektar::LibUtilities::BasisKey
Describes the specification for a Basis.
Definition: Basis.h:47
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition: Points.h:55
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition: NekMemoryManager.hpp:83
Nektar::Collections::OperatorImpMap
std::map< OperatorType, ImplementationType > OperatorImpMap
Definition: Operator.h:112
Nektar::HexCollectionTests::CreateHex
SpatialDomains::HexGeomSharedPtr CreateHex(SpatialDomains::PointGeomSharedPtr v0, SpatialDomains::PointGeomSharedPtr v1, SpatialDomains::PointGeomSharedPtr v2, SpatialDomains::PointGeomSharedPtr v3, SpatialDomains::PointGeomSharedPtr v4, SpatialDomains::PointGeomSharedPtr v5, SpatialDomains::PointGeomSharedPtr v6, SpatialDomains::PointGeomSharedPtr v7)
Definition: TestHexCollection.cpp:56
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:115
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:53
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LocalRegions::HexExpSharedPtr
std::shared_ptr< HexExp > HexExpSharedPtr
Definition: HexExp.h:260
Nektar::SpatialDomains::HexGeomSharedPtr
std::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:87
Nektar::SpatialDomains::PointGeomSharedPtr
std::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:60
Nektar::StdRegions::StdHexExpSharedPtr
std::shared_ptr< StdHexExp > StdHexExpSharedPtr
Definition: StdHexExp.h:255

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [2/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_IterPerExp_VariableP  )

Definition at line 307 of file TestHexCollection.cpp.

308{
309 SpatialDomains::PointGeomSharedPtr v0(
310 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
311 SpatialDomains::PointGeomSharedPtr v1(
312 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
313 SpatialDomains::PointGeomSharedPtr v2(
314 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
315 SpatialDomains::PointGeomSharedPtr v3(
316 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
317 SpatialDomains::PointGeomSharedPtr v4(
318 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
319 SpatialDomains::PointGeomSharedPtr v5(
320 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
321 SpatialDomains::PointGeomSharedPtr v6(
322 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
323 SpatialDomains::PointGeomSharedPtr v7(
324 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
325
326 SpatialDomains::HexGeomSharedPtr hexGeom =
327 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
328
329 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
330 Nektar::LibUtilities::eGaussLobattoLegendre;
331 Nektar::LibUtilities::BasisType basisTypeDir1 =
332 Nektar::LibUtilities::eModified_A;
333 unsigned int numQuadPoints = 6;
334 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
335 quadPointsTypeDir1);
336 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
337 quadPointsKeyDir1);
338 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
339 quadPointsKeyDir1);
340 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
341 quadPointsKeyDir1);
342
343 Nektar::LocalRegions::HexExpSharedPtr Exp =
344 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
345 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
346
347 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
348 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
349 basisKeyDir1, basisKeyDir2, basisKeyDir3);
350
351 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
352 CollExp.push_back(Exp);
353
354 LibUtilities::SessionReaderSharedPtr dummySession;
355 Collections::CollectionOptimisation colOpt(dummySession, 3,
356 Collections::eIterPerExp);
357 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
358 Collections::Collection c(CollExp, impTypes);
359 c.Initialise(Collections::eBwdTrans);
360
361 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
362 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
363 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
364
365 Exp->BwdTrans(coeffs, phys1);
366 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
367 c.Initialise(Collections::eBwdTrans);
368
369 double epsilon = 1.0e-8;
370 for (int i = 0; i < phys1.size(); ++i)
371 {
372 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
373 }
374}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [3/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_IterPerExp_VariableP_MultiElmt  )

Definition at line 376 of file TestHexCollection.cpp.

377{
378 SpatialDomains::PointGeomSharedPtr v0(
379 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
380 SpatialDomains::PointGeomSharedPtr v1(
381 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
382 SpatialDomains::PointGeomSharedPtr v2(
383 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
384 SpatialDomains::PointGeomSharedPtr v3(
385 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
386 SpatialDomains::PointGeomSharedPtr v4(
387 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
388 SpatialDomains::PointGeomSharedPtr v5(
389 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
390 SpatialDomains::PointGeomSharedPtr v6(
391 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
392 SpatialDomains::PointGeomSharedPtr v7(
393 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
394
395 SpatialDomains::HexGeomSharedPtr hexGeom =
396 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
397
398 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
399 Nektar::LibUtilities::eGaussLobattoLegendre;
400 Nektar::LibUtilities::BasisType basisTypeDir1 =
401 Nektar::LibUtilities::eModified_A;
402 unsigned int numQuadPoints = 6;
403 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
404 quadPointsTypeDir1);
405 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
406 quadPointsKeyDir1);
407 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
408 quadPointsKeyDir1);
409 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
410 quadPointsKeyDir1);
411
412 Nektar::LocalRegions::HexExpSharedPtr Exp =
413 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
414 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
415
416 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
417 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
418 basisKeyDir1, basisKeyDir2, basisKeyDir3);
419
420 int nelmts = 10;
421
422 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
423 for (int i = 0; i < nelmts; ++i)
424 CollExp.push_back(Exp);
425
426 LibUtilities::SessionReaderSharedPtr dummySession;
427 Collections::CollectionOptimisation colOpt(dummySession, 3,
428 Collections::eIterPerExp);
429 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
430 Collections::Collection c(CollExp, impTypes);
431 c.Initialise(Collections::eBwdTrans);
432
433 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
434 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
435 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
436
437 for (int i = 0; i < nelmts; ++i)
438 {
439 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
440 tmp = phys1 + i * Exp->GetTotPoints());
441 }
442
443 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
444
445 double epsilon = 1.0e-8;
446 for (int i = 0; i < phys1.size(); ++i)
447 {
448 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
449 }
450}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [4/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_MatrixFree_UniformP  )

Definition at line 823 of file TestHexCollection.cpp.

824{
825 SpatialDomains::PointGeomSharedPtr v0(
826 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
827 SpatialDomains::PointGeomSharedPtr v1(
828 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
829 SpatialDomains::PointGeomSharedPtr v2(
830 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
831 SpatialDomains::PointGeomSharedPtr v3(
832 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
833 SpatialDomains::PointGeomSharedPtr v4(
834 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
835 SpatialDomains::PointGeomSharedPtr v5(
836 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
837 SpatialDomains::PointGeomSharedPtr v6(
838 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
839 SpatialDomains::PointGeomSharedPtr v7(
840 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
841
842 SpatialDomains::HexGeomSharedPtr hexGeom =
843 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
844
845 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
846 Nektar::LibUtilities::eGaussLobattoLegendre;
847 Nektar::LibUtilities::BasisType basisTypeDir1 =
848 Nektar::LibUtilities::eModified_A;
849 unsigned int numQuadPoints = 6;
850 unsigned int numModes = 4;
851 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
852 quadPointsTypeDir1);
853 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
854 quadPointsKeyDir1);
855
856 Nektar::LocalRegions::HexExpSharedPtr Exp =
857 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
858 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
859
860 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
861 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
862 basisKeyDir1, basisKeyDir1, basisKeyDir1);
863
864 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
865 CollExp.push_back(Exp);
866
867 LibUtilities::SessionReaderSharedPtr dummySession;
868 Collections::CollectionOptimisation colOpt(dummySession, 2,
869 Collections::eMatrixFree);
870 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
871 Collections::Collection c(CollExp, impTypes);
872 c.Initialise(Collections::eBwdTrans);
873
874 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
875 Array<OneD, NekDouble> physRef(Exp->GetTotPoints());
876 Array<OneD, NekDouble> phys(Exp->GetTotPoints());
877
878 Exp->BwdTrans(coeffs, physRef);
879 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys);
880
881 double epsilon = 1.0e-8;
882 for (int i = 0; i < physRef.size(); ++i)
883 {
884 BOOST_CHECK_CLOSE(physRef[i], phys[i], epsilon);
885 }
886}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [5/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_NoCollection_VariableP  )

Definition at line 452 of file TestHexCollection.cpp.

453{
454 SpatialDomains::PointGeomSharedPtr v0(
455 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
456 SpatialDomains::PointGeomSharedPtr v1(
457 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
458 SpatialDomains::PointGeomSharedPtr v2(
459 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
460 SpatialDomains::PointGeomSharedPtr v3(
461 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
462 SpatialDomains::PointGeomSharedPtr v4(
463 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
464 SpatialDomains::PointGeomSharedPtr v5(
465 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
466 SpatialDomains::PointGeomSharedPtr v6(
467 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
468 SpatialDomains::PointGeomSharedPtr v7(
469 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
470
471 SpatialDomains::HexGeomSharedPtr hexGeom =
472 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
473
474 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
475 Nektar::LibUtilities::eGaussLobattoLegendre;
476 Nektar::LibUtilities::BasisType basisTypeDir1 =
477 Nektar::LibUtilities::eModified_A;
478 unsigned int numQuadPoints = 6;
479 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
480 quadPointsTypeDir1);
481 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
482 quadPointsKeyDir1);
483 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
484 quadPointsKeyDir1);
485 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
486 quadPointsKeyDir1);
487
488 Nektar::LocalRegions::HexExpSharedPtr Exp =
489 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
490 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
491
492 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
493 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
494 basisKeyDir1, basisKeyDir2, basisKeyDir3);
495
496 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
497 CollExp.push_back(Exp);
498
499 LibUtilities::SessionReaderSharedPtr dummySession;
500 Collections::CollectionOptimisation colOpt(dummySession, 2,
501 Collections::eNoCollection);
502 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
503 Collections::Collection c(CollExp, impTypes);
504 c.Initialise(Collections::eBwdTrans);
505
506 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
507 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
508 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
509
510 Exp->BwdTrans(coeffs, phys1);
511
512 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
513
514 double epsilon = 1.0e-8;
515 for (int i = 0; i < phys1.size(); ++i)
516 {
517 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
518 }
519}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eNoCollection, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [6/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_StdMat_UniformP  )

Definition at line 112 of file TestHexCollection.cpp.

113{
114 SpatialDomains::PointGeomSharedPtr v0(
115 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
116 SpatialDomains::PointGeomSharedPtr v1(
117 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
118 SpatialDomains::PointGeomSharedPtr v2(
119 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
120 SpatialDomains::PointGeomSharedPtr v3(
121 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
122 SpatialDomains::PointGeomSharedPtr v4(
123 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
124 SpatialDomains::PointGeomSharedPtr v5(
125 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
126 SpatialDomains::PointGeomSharedPtr v6(
127 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
128 SpatialDomains::PointGeomSharedPtr v7(
129 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
130
131 SpatialDomains::HexGeomSharedPtr hexGeom =
132 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
133
134 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
135 Nektar::LibUtilities::eGaussLobattoLegendre;
136 Nektar::LibUtilities::BasisType basisTypeDir1 =
137 Nektar::LibUtilities::eModified_A;
138 unsigned int numQuadPoints = 6;
139 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
140 quadPointsTypeDir1);
141 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
142 quadPointsKeyDir1);
143
144 Nektar::LocalRegions::HexExpSharedPtr Exp =
145 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
146 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
147
148 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
149 CollExp.push_back(Exp);
150
151 LibUtilities::SessionReaderSharedPtr dummySession;
152 Collections::CollectionOptimisation colOpt(dummySession, 3,
153 Collections::eStdMat);
154 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(Exp);
155 Collections::Collection c(CollExp, impTypes);
156 c.Initialise(Collections::eBwdTrans);
157
158 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
159 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
160 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
161
162 Exp->BwdTrans(coeffs, phys1);
163 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
164
165 double epsilon = 1.0e-8;
166 for (int i = 0; i < phys1.size(); ++i)
167 {
168 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
169 }
170}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [7/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_StdMat_VariableP  )

Definition at line 172 of file TestHexCollection.cpp.

173{
174 SpatialDomains::PointGeomSharedPtr v0(
175 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
176 SpatialDomains::PointGeomSharedPtr v1(
177 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
178 SpatialDomains::PointGeomSharedPtr v2(
179 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
180 SpatialDomains::PointGeomSharedPtr v3(
181 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
182 SpatialDomains::PointGeomSharedPtr v4(
183 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
184 SpatialDomains::PointGeomSharedPtr v5(
185 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
186 SpatialDomains::PointGeomSharedPtr v6(
187 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
188 SpatialDomains::PointGeomSharedPtr v7(
189 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
190
191 SpatialDomains::HexGeomSharedPtr hexGeom =
192 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
193
194 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
195 Nektar::LibUtilities::eGaussLobattoLegendre;
196 Nektar::LibUtilities::BasisType basisTypeDir1 =
197 Nektar::LibUtilities::eModified_A;
198 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
199 quadPointsTypeDir1);
200 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
201 quadPointsTypeDir1);
202 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
203 quadPointsTypeDir1);
204 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
205 quadPointsKeyDir1);
206 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
207 quadPointsKeyDir2);
208 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
209 quadPointsKeyDir3);
210
211 Nektar::LocalRegions::HexExpSharedPtr Exp =
212 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
213 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
214
215 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
216 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
217 basisKeyDir1, basisKeyDir2, basisKeyDir3);
218
219 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
220 CollExp.push_back(Exp);
221
222 LibUtilities::SessionReaderSharedPtr dummySession;
223 Collections::CollectionOptimisation colOpt(dummySession, 3,
224 Collections::eStdMat);
225 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
226 Collections::Collection c(CollExp, impTypes);
227 c.Initialise(Collections::eBwdTrans);
228
229 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs(), 1.0), tmp;
230 Array<OneD, NekDouble> phys1(Exp->GetTotPoints());
231 Array<OneD, NekDouble> phys2(Exp->GetTotPoints());
232
233 Exp->BwdTrans(coeffs, phys1);
234 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
235
236 double epsilon = 1.0e-8;
237 for (int i = 0; i < phys1.size(); ++i)
238 {
239 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
240 }
241}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [8/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_SumFac_UniformP  )

Definition at line 521 of file TestHexCollection.cpp.

522{
523 SpatialDomains::PointGeomSharedPtr v0(
524 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
525 SpatialDomains::PointGeomSharedPtr v1(
526 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
527 SpatialDomains::PointGeomSharedPtr v2(
528 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
529 SpatialDomains::PointGeomSharedPtr v3(
530 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
531 SpatialDomains::PointGeomSharedPtr v4(
532 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
533 SpatialDomains::PointGeomSharedPtr v5(
534 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
535 SpatialDomains::PointGeomSharedPtr v6(
536 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
537 SpatialDomains::PointGeomSharedPtr v7(
538 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
539
540 SpatialDomains::HexGeomSharedPtr hexGeom =
541 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
542
543 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
544 Nektar::LibUtilities::eGaussLobattoLegendre;
545 Nektar::LibUtilities::BasisType basisTypeDir1 =
546 Nektar::LibUtilities::eModified_A;
547 unsigned int numQuadPoints = 6;
548 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
549 quadPointsTypeDir1);
550 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
551 quadPointsKeyDir1);
552
553 Nektar::LocalRegions::HexExpSharedPtr Exp =
554 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
555 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
556
557 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
558 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
559 basisKeyDir1, basisKeyDir1, basisKeyDir1);
560
561 int nelmts = 1;
562
563 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
564 for (int i = 0; i < nelmts; ++i)
565 CollExp.push_back(Exp);
566
567 LibUtilities::SessionReaderSharedPtr dummySession;
568 Collections::CollectionOptimisation colOpt(dummySession, 3,
569 Collections::eSumFac);
570 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
571 Collections::Collection c(CollExp, impTypes);
572 c.Initialise(Collections::eBwdTrans);
573
574 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
575 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
576 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
577
578 for (int i = 0; i < nelmts; ++i)
579 {
580 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
581 tmp = phys1 + i * Exp->GetTotPoints());
582 }
583 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
584
585 double epsilon = 1.0e-8;
586 for (int i = 0; i < phys1.size(); ++i)
587 {
588 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
589 }
590}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [9/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_SumFac_UniformP_MultiElmt  )

Definition at line 592 of file TestHexCollection.cpp.

593{
594 SpatialDomains::PointGeomSharedPtr v0(
595 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
596 SpatialDomains::PointGeomSharedPtr v1(
597 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
598 SpatialDomains::PointGeomSharedPtr v2(
599 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
600 SpatialDomains::PointGeomSharedPtr v3(
601 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
602 SpatialDomains::PointGeomSharedPtr v4(
603 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
604 SpatialDomains::PointGeomSharedPtr v5(
605 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
606 SpatialDomains::PointGeomSharedPtr v6(
607 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
608 SpatialDomains::PointGeomSharedPtr v7(
609 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
610
611 SpatialDomains::HexGeomSharedPtr hexGeom =
612 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
613
614 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
615 Nektar::LibUtilities::eGaussLobattoLegendre;
616 Nektar::LibUtilities::BasisType basisTypeDir1 =
617 Nektar::LibUtilities::eModified_A;
618 unsigned int numQuadPoints = 6;
619 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
620 quadPointsTypeDir1);
621 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
622 quadPointsKeyDir1);
623
624 Nektar::LocalRegions::HexExpSharedPtr Exp =
625 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
626 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
627
628 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
629 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
630 basisKeyDir1, basisKeyDir1, basisKeyDir1);
631
632 int nelmts = 10;
633
634 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
635 for (int i = 0; i < nelmts; ++i)
636 CollExp.push_back(Exp);
637
638 LibUtilities::SessionReaderSharedPtr dummySession;
639 Collections::CollectionOptimisation colOpt(dummySession, 3,
640 Collections::eSumFac);
641 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
642 Collections::Collection c(CollExp, impTypes);
643 c.Initialise(Collections::eBwdTrans);
644
645 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
646 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
647 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
648
649 for (int i = 0; i < nelmts; ++i)
650 {
651 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
652 tmp = phys1 + i * Exp->GetTotPoints());
653 }
654 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
655
656 double epsilon = 1.0e-8;
657 for (int i = 0; i < phys1.size(); ++i)
658 {
659 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
660 }
661}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [10/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_SumFac_VariableP  )

Definition at line 663 of file TestHexCollection.cpp.

664{
665 SpatialDomains::PointGeomSharedPtr v0(
666 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
667 SpatialDomains::PointGeomSharedPtr v1(
668 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
669 SpatialDomains::PointGeomSharedPtr v2(
670 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
671 SpatialDomains::PointGeomSharedPtr v3(
672 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
673 SpatialDomains::PointGeomSharedPtr v4(
674 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
675 SpatialDomains::PointGeomSharedPtr v5(
676 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
677 SpatialDomains::PointGeomSharedPtr v6(
678 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
679 SpatialDomains::PointGeomSharedPtr v7(
680 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
681
682 SpatialDomains::HexGeomSharedPtr hexGeom =
683 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
684
685 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
686 Nektar::LibUtilities::eGaussLobattoLegendre;
687 Nektar::LibUtilities::BasisType basisTypeDir1 =
688 Nektar::LibUtilities::eModified_A;
689 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
690 quadPointsTypeDir1);
691 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
692 quadPointsTypeDir1);
693 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
694 quadPointsTypeDir1);
695 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
696 quadPointsKeyDir1);
697 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
698 quadPointsKeyDir2);
699 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
700 quadPointsKeyDir3);
701
702 Nektar::LocalRegions::HexExpSharedPtr Exp =
703 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
704 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
705
706 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
707 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
708 basisKeyDir1, basisKeyDir2, basisKeyDir3);
709
710 int nelmts = 1;
711
712 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
713 for (int i = 0; i < nelmts; ++i)
714 {
715 CollExp.push_back(Exp);
716 }
717
718 LibUtilities::SessionReaderSharedPtr dummySession;
719 Collections::CollectionOptimisation colOpt(dummySession, 3,
720 Collections::eSumFac);
721 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
722 Collections::Collection c(CollExp, impTypes);
723 c.Initialise(Collections::eBwdTrans);
724
725 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
726 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
727 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
728
729 for (int i = 0; i < nelmts; ++i)
730 {
731 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
732 tmp = phys1 + i * Exp->GetTotPoints());
733 }
734 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
735
736 double epsilon = 1.0e-8;
737 for (int i = 0; i < phys1.size(); ++i)
738 {
739 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
740 }
741}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [11/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexBwdTrans_SumFac_VariableP_MultiElmt  )

Definition at line 743 of file TestHexCollection.cpp.

744{
745 SpatialDomains::PointGeomSharedPtr v0(
746 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
747 SpatialDomains::PointGeomSharedPtr v1(
748 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
749 SpatialDomains::PointGeomSharedPtr v2(
750 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
751 SpatialDomains::PointGeomSharedPtr v3(
752 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
753 SpatialDomains::PointGeomSharedPtr v4(
754 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
755 SpatialDomains::PointGeomSharedPtr v5(
756 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
757 SpatialDomains::PointGeomSharedPtr v6(
758 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
759 SpatialDomains::PointGeomSharedPtr v7(
760 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
761
762 SpatialDomains::HexGeomSharedPtr hexGeom =
763 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
764
765 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
766 Nektar::LibUtilities::eGaussLobattoLegendre;
767 Nektar::LibUtilities::BasisType basisTypeDir1 =
768 Nektar::LibUtilities::eModified_A;
769 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
770 quadPointsTypeDir1);
771 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
772 quadPointsTypeDir1);
773 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
774 quadPointsTypeDir1);
775 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
776 quadPointsKeyDir1);
777 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
778 quadPointsKeyDir2);
779 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
780 quadPointsKeyDir3);
781
782 Nektar::LocalRegions::HexExpSharedPtr Exp =
783 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
784 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
785
786 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
787 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
788 basisKeyDir1, basisKeyDir2, basisKeyDir3);
789
790 int nelmts = 10;
791
792 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
793 for (int i = 0; i < nelmts; ++i)
794 {
795 CollExp.push_back(Exp);
796 }
797
798 LibUtilities::SessionReaderSharedPtr dummySession;
799 Collections::CollectionOptimisation colOpt(dummySession, 3,
800 Collections::eSumFac);
801 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
802 Collections::Collection c(CollExp, impTypes);
803 c.Initialise(Collections::eBwdTrans);
804
805 Array<OneD, NekDouble> coeffs(nelmts * Exp->GetNcoeffs(), 1.0), tmp;
806 Array<OneD, NekDouble> phys1(nelmts * Exp->GetTotPoints());
807 Array<OneD, NekDouble> phys2(nelmts * Exp->GetTotPoints());
808
809 for (int i = 0; i < nelmts; ++i)
810 {
811 Exp->BwdTrans(coeffs + i * Exp->GetNcoeffs(),
812 tmp = phys1 + i * Exp->GetTotPoints());
813 }
814 c.ApplyOperator(Collections::eBwdTrans, coeffs, phys2);
815
816 double epsilon = 1.0e-8;
817 for (int i = 0; i < phys1.size(); ++i)
818 {
819 BOOST_CHECK_CLOSE(phys1[i], phys2[i], epsilon);
820 }
821}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::Collections::eBwdTrans, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [12/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_IterPerExp_UniformP  )

Definition at line 4151 of file TestHexCollection.cpp.

4152{
4153 SpatialDomains::PointGeomSharedPtr v0(
4154 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4155 SpatialDomains::PointGeomSharedPtr v1(
4156 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4157 SpatialDomains::PointGeomSharedPtr v2(
4158 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4159 SpatialDomains::PointGeomSharedPtr v3(
4160 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4161 SpatialDomains::PointGeomSharedPtr v4(
4162 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4163 SpatialDomains::PointGeomSharedPtr v5(
4164 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4165 SpatialDomains::PointGeomSharedPtr v6(
4166 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4167 SpatialDomains::PointGeomSharedPtr v7(
4168 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4169
4170 SpatialDomains::HexGeomSharedPtr hexGeom =
4171 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4172
4173 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4174 Nektar::LibUtilities::eGaussLobattoLegendre;
4175 Nektar::LibUtilities::BasisType basisTypeDir1 =
4176 Nektar::LibUtilities::eModified_A;
4177 unsigned int numQuadPoints = 5;
4178 unsigned int numModes = 4;
4179
4180 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4181 quadPointsTypeDir1);
4182 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4183 quadPointsKeyDir1);
4184
4185 Nektar::LocalRegions::HexExpSharedPtr Exp =
4186 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4187 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4188
4189 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4190 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4191 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4192
4193 int nelmts = 10;
4194
4195 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4196 for (int i = 0; i < nelmts; ++i)
4197 {
4198 CollExp.push_back(Exp);
4199 }
4200
4201 LibUtilities::SessionReaderSharedPtr dummySession;
4202 Collections::CollectionOptimisation colOpt(dummySession, 2,
4203 Collections::eIterPerExp);
4204 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4205 Collections::Collection c(CollExp, impTypes);
4206 StdRegions::ConstFactorMap factors;
4207 factors[StdRegions::eFactorLambda] = 1.5;
4208
4209 c.Initialise(Collections::eHelmholtz, factors);
4210
4211 const int nm = Exp->GetNcoeffs();
4212 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4213 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4214 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4215
4216 for (int i = 0; i < nm; ++i)
4217 {
4218 coeffsIn[i] = 1.0;
4219 }
4220
4221 for (int i = 1; i < nelmts; ++i)
4222 {
4223 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4224 }
4225
4226 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4227 *Exp, factors);
4228
4229 for (int i = 0; i < nelmts; ++i)
4230 {
4231 // Standard routines
4232 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4233 }
4234
4235 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4236
4237 double epsilon = 1.0e-8;
4238 for (int i = 0; i < coeffsRef.size(); ++i)
4239 {
4240 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4241 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4242 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4243 }
4244}
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:408
Nektar::VarcoeffHashingTest::factors
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:52
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191
tinysimd::abs
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:298

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [13/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_IterPerExp_UniformP_ConstVarDiff  )

Definition at line 4246 of file TestHexCollection.cpp.

4247{
4248 SpatialDomains::PointGeomSharedPtr v0(
4249 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4250 SpatialDomains::PointGeomSharedPtr v1(
4251 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4252 SpatialDomains::PointGeomSharedPtr v2(
4253 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4254 SpatialDomains::PointGeomSharedPtr v3(
4255 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4256 SpatialDomains::PointGeomSharedPtr v4(
4257 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4258 SpatialDomains::PointGeomSharedPtr v5(
4259 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4260 SpatialDomains::PointGeomSharedPtr v6(
4261 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4262 SpatialDomains::PointGeomSharedPtr v7(
4263 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4264
4265 SpatialDomains::HexGeomSharedPtr hexGeom =
4266 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4267
4268 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4269 Nektar::LibUtilities::eGaussLobattoLegendre;
4270 Nektar::LibUtilities::BasisType basisTypeDir1 =
4271 Nektar::LibUtilities::eModified_A;
4272 unsigned int numQuadPoints = 5;
4273 unsigned int numModes = 4;
4274
4275 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4276 quadPointsTypeDir1);
4277 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4278 quadPointsKeyDir1);
4279
4280 Nektar::LocalRegions::HexExpSharedPtr Exp =
4281 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4282 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4283
4284 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4285 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4286 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4287
4288 int nelmts = 10;
4289
4290 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4291 for (int i = 0; i < nelmts; ++i)
4292 {
4293 CollExp.push_back(Exp);
4294 }
4295
4296 LibUtilities::SessionReaderSharedPtr dummySession;
4297 Collections::CollectionOptimisation colOpt(dummySession, 2,
4298 Collections::eIterPerExp);
4299 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4300 Collections::Collection c(CollExp, impTypes);
4301 StdRegions::ConstFactorMap factors;
4302 factors[StdRegions::eFactorLambda] = 1.5;
4303 factors[StdRegions::eFactorCoeffD00] = 1.25;
4304 factors[StdRegions::eFactorCoeffD01] = 0.25;
4305 factors[StdRegions::eFactorCoeffD11] = 1.25;
4306 factors[StdRegions::eFactorCoeffD02] = 0.25;
4307 factors[StdRegions::eFactorCoeffD12] = 0.25;
4308 factors[StdRegions::eFactorCoeffD22] = 1.25;
4309
4310 c.Initialise(Collections::eHelmholtz, factors);
4311
4312 const int nm = Exp->GetNcoeffs();
4313 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4314 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4315 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4316
4317 for (int i = 0; i < nm; ++i)
4318 {
4319 coeffsIn[i] = 1.0;
4320 }
4321
4322 for (int i = 1; i < nelmts; ++i)
4323 {
4324 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4325 }
4326
4327 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4328 *Exp, factors);
4329
4330 for (int i = 0; i < nelmts; ++i)
4331 {
4332 // Standard routines
4333 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4334 }
4335
4336 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4337
4338 double epsilon = 1.0e-8;
4339 for (int i = 0; i < coeffsRef.size(); ++i)
4340 {
4341 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4342 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4343 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4344 }
4345}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorCoeffD00, Nektar::StdRegions::eFactorCoeffD01, Nektar::StdRegions::eFactorCoeffD02, Nektar::StdRegions::eFactorCoeffD11, Nektar::StdRegions::eFactorCoeffD12, Nektar::StdRegions::eFactorCoeffD22, Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [14/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_MatrixFree_UniformP  )

Definition at line 4347 of file TestHexCollection.cpp.

4348{
4349 SpatialDomains::PointGeomSharedPtr v0(
4350 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4351 SpatialDomains::PointGeomSharedPtr v1(
4352 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4353 SpatialDomains::PointGeomSharedPtr v2(
4354 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4355 SpatialDomains::PointGeomSharedPtr v3(
4356 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4357 SpatialDomains::PointGeomSharedPtr v4(
4358 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4359 SpatialDomains::PointGeomSharedPtr v5(
4360 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4361 SpatialDomains::PointGeomSharedPtr v6(
4362 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4363 SpatialDomains::PointGeomSharedPtr v7(
4364 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4365
4366 SpatialDomains::HexGeomSharedPtr hexGeom =
4367 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4368
4369 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4370 Nektar::LibUtilities::eGaussLobattoLegendre;
4371 Nektar::LibUtilities::BasisType basisTypeDir1 =
4372 Nektar::LibUtilities::eModified_A;
4373 unsigned int numQuadPoints = 5;
4374 unsigned int numModes = 4;
4375
4376 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4377 quadPointsTypeDir1);
4378 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4379 quadPointsKeyDir1);
4380
4381 Nektar::LocalRegions::HexExpSharedPtr Exp =
4382 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4383 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4384
4385 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4386 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4387 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4388
4389 int nelmts = 10;
4390
4391 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4392 for (int i = 0; i < nelmts; ++i)
4393 {
4394 CollExp.push_back(Exp);
4395 }
4396
4397 LibUtilities::SessionReaderSharedPtr dummySession;
4398 Collections::CollectionOptimisation colOpt(dummySession, 2,
4399 Collections::eMatrixFree);
4400 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4401 Collections::Collection c(CollExp, impTypes);
4402 StdRegions::ConstFactorMap factors;
4403 factors[StdRegions::eFactorLambda] = 0.0;
4404
4405 c.Initialise(Collections::eHelmholtz, factors);
4406
4407 const int nm = Exp->GetNcoeffs();
4408 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4409 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4410 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4411
4412 for (int i = 0; i < nm; ++i)
4413 {
4414 coeffsIn[i] = 1.0;
4415 }
4416
4417 for (int i = 1; i < nelmts; ++i)
4418 {
4419 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4420 }
4421
4422 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4423 *Exp, factors);
4424
4425 for (int i = 0; i < nelmts; ++i)
4426 {
4427 // Standard routines
4428 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4429 }
4430
4431 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4432
4433 double epsilon = 1.0e-8;
4434 for (int i = 0; i < coeffsRef.size(); ++i)
4435 {
4436 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4437 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4438 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4439 }
4440}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [15/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_MatrixFree_UniformP_ConstVarDiff  )

Definition at line 4537 of file TestHexCollection.cpp.

4538{
4539 SpatialDomains::PointGeomSharedPtr v0(
4540 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4541 SpatialDomains::PointGeomSharedPtr v1(
4542 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4543 SpatialDomains::PointGeomSharedPtr v2(
4544 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4545 SpatialDomains::PointGeomSharedPtr v3(
4546 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4547 SpatialDomains::PointGeomSharedPtr v4(
4548 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4549 SpatialDomains::PointGeomSharedPtr v5(
4550 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4551 SpatialDomains::PointGeomSharedPtr v6(
4552 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4553 SpatialDomains::PointGeomSharedPtr v7(
4554 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4555
4556 SpatialDomains::HexGeomSharedPtr hexGeom =
4557 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4558
4559 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4560 Nektar::LibUtilities::eGaussLobattoLegendre;
4561 Nektar::LibUtilities::BasisType basisTypeDir1 =
4562 Nektar::LibUtilities::eModified_A;
4563 unsigned int numQuadPoints = 5;
4564 unsigned int numModes = 4;
4565
4566 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4567 quadPointsTypeDir1);
4568 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4569 quadPointsKeyDir1);
4570
4571 Nektar::LocalRegions::HexExpSharedPtr Exp =
4572 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4573 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4574
4575 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4576 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4577 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4578
4579 int nelmts = 10;
4580
4581 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4582 for (int i = 0; i < nelmts; ++i)
4583 {
4584 CollExp.push_back(Exp);
4585 }
4586
4587 LibUtilities::SessionReaderSharedPtr dummySession;
4588 Collections::CollectionOptimisation colOpt(dummySession, 2,
4589 Collections::eMatrixFree);
4590 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4591 Collections::Collection c(CollExp, impTypes);
4592 StdRegions::ConstFactorMap factors;
4593 factors[StdRegions::eFactorLambda] = 1.0;
4594 factors[StdRegions::eFactorCoeffD00] = 1.25;
4595 factors[StdRegions::eFactorCoeffD01] = 0.25;
4596 factors[StdRegions::eFactorCoeffD11] = 1.25;
4597 factors[StdRegions::eFactorCoeffD02] = 0.25;
4598 factors[StdRegions::eFactorCoeffD12] = 0.25;
4599 factors[StdRegions::eFactorCoeffD22] = 1.25;
4600
4601 c.Initialise(Collections::eHelmholtz, factors);
4602
4603 const int nm = Exp->GetNcoeffs();
4604 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4605 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4606 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4607
4608 for (int i = 0; i < nm; ++i)
4609 {
4610 coeffsIn[i] = 1.0;
4611 }
4612
4613 for (int i = 1; i < nelmts; ++i)
4614 {
4615 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4616 }
4617
4618 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4619 *Exp, factors);
4620
4621 for (int i = 0; i < nelmts; ++i)
4622 {
4623 // Standard routines
4624 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4625 }
4626
4627 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4628
4629 double epsilon = 1.0e-8;
4630 for (int i = 0; i < coeffsRef.size(); ++i)
4631 {
4632 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4633 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4634 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4635 }
4636}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorCoeffD00, Nektar::StdRegions::eFactorCoeffD01, Nektar::StdRegions::eFactorCoeffD02, Nektar::StdRegions::eFactorCoeffD11, Nektar::StdRegions::eFactorCoeffD12, Nektar::StdRegions::eFactorCoeffD22, Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [16/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_MatrixFree_UniformP_Deformed_OverInt  )

Definition at line 4442 of file TestHexCollection.cpp.

4443{
4444 SpatialDomains::PointGeomSharedPtr v0(
4445 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4446 SpatialDomains::PointGeomSharedPtr v1(
4447 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4448 SpatialDomains::PointGeomSharedPtr v2(
4449 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4450 SpatialDomains::PointGeomSharedPtr v3(
4451 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4452 SpatialDomains::PointGeomSharedPtr v4(
4453 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4454 SpatialDomains::PointGeomSharedPtr v5(
4455 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4456 SpatialDomains::PointGeomSharedPtr v6(
4457 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4458 SpatialDomains::PointGeomSharedPtr v7(
4459 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4460
4461 SpatialDomains::HexGeomSharedPtr hexGeom =
4462 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4463
4464 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4465 Nektar::LibUtilities::eGaussLobattoLegendre;
4466 Nektar::LibUtilities::BasisType basisTypeDir1 =
4467 Nektar::LibUtilities::eModified_A;
4468 unsigned int numQuadPoints = 8;
4469 unsigned int numModes = 4;
4470
4471 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4472 quadPointsTypeDir1);
4473 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4474 quadPointsKeyDir1);
4475
4476 Nektar::LocalRegions::HexExpSharedPtr Exp =
4477 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4478 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4479
4480 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4481 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4482 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4483
4484 int nelmts = 10;
4485
4486 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4487 for (int i = 0; i < nelmts; ++i)
4488 {
4489 CollExp.push_back(Exp);
4490 }
4491
4492 LibUtilities::SessionReaderSharedPtr dummySession;
4493 Collections::CollectionOptimisation colOpt(dummySession, 2,
4494 Collections::eMatrixFree);
4495 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4496 Collections::Collection c(CollExp, impTypes);
4497 StdRegions::ConstFactorMap factors;
4498 factors[StdRegions::eFactorLambda] = 0.0;
4499
4500 c.Initialise(Collections::eHelmholtz, factors);
4501
4502 const int nm = Exp->GetNcoeffs();
4503 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4504 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4505 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4506
4507 for (int i = 0; i < nm; ++i)
4508 {
4509 coeffsIn[i] = 1.0;
4510 }
4511
4512 for (int i = 1; i < nelmts; ++i)
4513 {
4514 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4515 }
4516
4517 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4518 *Exp, factors);
4519
4520 for (int i = 0; i < nelmts; ++i)
4521 {
4522 // Standard routines
4523 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4524 }
4525
4526 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4527
4528 double epsilon = 1.0e-8;
4529 for (int i = 0; i < coeffsRef.size(); ++i)
4530 {
4531 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4532 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4533 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4534 }
4535}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [17/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexHelmholtz_NoCollection_UniformP  )

Definition at line 4056 of file TestHexCollection.cpp.

4057{
4058 SpatialDomains::PointGeomSharedPtr v0(
4059 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
4060 SpatialDomains::PointGeomSharedPtr v1(
4061 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
4062 SpatialDomains::PointGeomSharedPtr v2(
4063 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
4064 SpatialDomains::PointGeomSharedPtr v3(
4065 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
4066 SpatialDomains::PointGeomSharedPtr v4(
4067 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
4068 SpatialDomains::PointGeomSharedPtr v5(
4069 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
4070 SpatialDomains::PointGeomSharedPtr v6(
4071 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
4072 SpatialDomains::PointGeomSharedPtr v7(
4073 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
4074
4075 SpatialDomains::HexGeomSharedPtr hexGeom =
4076 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
4077
4078 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
4079 Nektar::LibUtilities::eGaussLobattoLegendre;
4080 Nektar::LibUtilities::BasisType basisTypeDir1 =
4081 Nektar::LibUtilities::eModified_A;
4082 unsigned int numQuadPoints = 5;
4083 unsigned int numModes = 4;
4084
4085 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
4086 quadPointsTypeDir1);
4087 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
4088 quadPointsKeyDir1);
4089
4090 Nektar::LocalRegions::HexExpSharedPtr Exp =
4091 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
4092 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
4093
4094 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
4095 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
4096 basisKeyDir1, basisKeyDir1, basisKeyDir1);
4097
4098 int nelmts = 10;
4099
4100 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
4101 for (int i = 0; i < nelmts; ++i)
4102 {
4103 CollExp.push_back(Exp);
4104 }
4105
4106 LibUtilities::SessionReaderSharedPtr dummySession;
4107 Collections::CollectionOptimisation colOpt(dummySession, 2,
4108 Collections::eNoCollection);
4109 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4110 Collections::Collection c(CollExp, impTypes);
4111 StdRegions::ConstFactorMap factors;
4112 factors[StdRegions::eFactorLambda] = 1.5;
4113
4114 c.Initialise(Collections::eHelmholtz, factors);
4115
4116 const int nm = Exp->GetNcoeffs();
4117 Array<OneD, NekDouble> coeffsIn(nelmts * nm);
4118 Array<OneD, NekDouble> coeffsRef(nelmts * nm);
4119 Array<OneD, NekDouble> coeffs(nelmts * nm), tmp;
4120
4121 for (int i = 0; i < nm; ++i)
4122 {
4123 coeffsIn[i] = 1.0;
4124 }
4125
4126 for (int i = 1; i < nelmts; ++i)
4127 {
4128 Vmath::Vcopy(nm, coeffsIn, 1, tmp = coeffsIn + i * nm, 1);
4129 }
4130
4131 StdRegions::StdMatrixKey mkey(StdRegions::eHelmholtz, Exp->DetShapeType(),
4132 *Exp, factors);
4133
4134 for (int i = 0; i < nelmts; ++i)
4135 {
4136 // Standard routines
4137 Exp->GeneralMatrixOp(coeffsIn + i * nm, tmp = coeffsRef + i * nm, mkey);
4138 }
4139
4140 c.ApplyOperator(Collections::eHelmholtz, coeffsIn, coeffs);
4141
4142 double epsilon = 1.0e-8;
4143 for (int i = 0; i < coeffsRef.size(); ++i)
4144 {
4145 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
4146 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
4147 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
4148 }
4149}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::StdRegions::eFactorLambda, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eHelmholtz, Nektar::StdRegions::eHelmholtz, Nektar::LibUtilities::eModified_A, Nektar::Collections::eNoCollection, Nektar::VarcoeffHashingTest::factors, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [18/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_IterPerExp_VariableP_MultiElmt  )

Definition at line 1694 of file TestHexCollection.cpp.

1695{
1696 SpatialDomains::PointGeomSharedPtr v0(
1697 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1698 SpatialDomains::PointGeomSharedPtr v1(
1699 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1700 SpatialDomains::PointGeomSharedPtr v2(
1701 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1702 SpatialDomains::PointGeomSharedPtr v3(
1703 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1704 SpatialDomains::PointGeomSharedPtr v4(
1705 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1706 SpatialDomains::PointGeomSharedPtr v5(
1707 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1708 SpatialDomains::PointGeomSharedPtr v6(
1709 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1710 SpatialDomains::PointGeomSharedPtr v7(
1711 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1712
1713 SpatialDomains::HexGeomSharedPtr hexGeom =
1714 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1715
1716 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1717 Nektar::LibUtilities::eGaussLobattoLegendre;
1718 Nektar::LibUtilities::BasisType basisTypeDir1 =
1719 Nektar::LibUtilities::eModified_A;
1720 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1721 quadPointsTypeDir1);
1722 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1723 quadPointsTypeDir1);
1724 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
1725 quadPointsTypeDir1);
1726 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1727 quadPointsKeyDir1);
1728 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1729 quadPointsKeyDir2);
1730 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1731 quadPointsKeyDir3);
1732
1733 Nektar::LocalRegions::HexExpSharedPtr Exp =
1734 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1735 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1736
1737 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1738 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1739 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1740
1741 int nelmts = 10;
1742
1743 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1744 for (int i = 0; i < nelmts; ++i)
1745 {
1746 CollExp.push_back(Exp);
1747 }
1748
1749 LibUtilities::SessionReaderSharedPtr dummySession;
1750 Collections::CollectionOptimisation colOpt(dummySession, 3,
1751 Collections::eIterPerExp);
1752 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1753 Collections::Collection c(CollExp, impTypes);
1754 c.Initialise(Collections::eIProductWRTBase);
1755
1756 const int nq = Exp->GetTotPoints();
1757 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
1758 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
1759 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
1760
1761 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1762
1763 Exp->GetCoords(xc, yc, zc);
1764
1765 for (int i = 0; i < nq; ++i)
1766 {
1767 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1768 }
1769 Exp->IProductWRTBase(phys, coeffs1);
1770
1771 for (int i = 1; i < nelmts; ++i)
1772 {
1773 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
1774 Exp->IProductWRTBase(phys + i * nq,
1775 tmp = coeffs1 + i * Exp->GetNcoeffs());
1776 }
1777
1778 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1779
1780 double epsilon = 1.0e-8;
1781 for (int i = 0; i < coeffs1.size(); ++i)
1782 {
1783 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1784 }
1785}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [19/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_MatrixFree_UniformP_Deformed  )

Definition at line 1039 of file TestHexCollection.cpp.

1040{
1041 SpatialDomains::PointGeomSharedPtr v0(
1042 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
1043 SpatialDomains::PointGeomSharedPtr v1(
1044 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1045 SpatialDomains::PointGeomSharedPtr v2(
1046 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1047 SpatialDomains::PointGeomSharedPtr v3(
1048 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1049 SpatialDomains::PointGeomSharedPtr v4(
1050 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1051 SpatialDomains::PointGeomSharedPtr v5(
1052 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1053 SpatialDomains::PointGeomSharedPtr v6(
1054 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
1055 SpatialDomains::PointGeomSharedPtr v7(
1056 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1057
1058 SpatialDomains::HexGeomSharedPtr hexGeom =
1059 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1060
1061 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1062 Nektar::LibUtilities::eGaussLobattoLegendre;
1063 Nektar::LibUtilities::BasisType basisTypeDir1 =
1064 Nektar::LibUtilities::eModified_A;
1065 unsigned int numQuadPoints = 5;
1066 unsigned int numModes = 4;
1067 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
1068 quadPointsTypeDir1);
1069 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
1070 quadPointsKeyDir1);
1071
1072 Nektar::LocalRegions::HexExpSharedPtr Exp =
1073 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1074 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
1075
1076 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1077 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1078 basisKeyDir1, basisKeyDir1, basisKeyDir1);
1079
1080 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1081 CollExp.push_back(Exp);
1082
1083 LibUtilities::SessionReaderSharedPtr dummySession;
1084 Collections::CollectionOptimisation colOpt(dummySession, 2,
1085 Collections::eMatrixFree);
1086 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1087 Collections::Collection c(CollExp, impTypes);
1088 c.Initialise(Collections::eIProductWRTBase);
1089
1090 const int nq = Exp->GetTotPoints();
1091 Array<OneD, NekDouble> phys(nq);
1092 Array<OneD, NekDouble> coeffsRef(Exp->GetNcoeffs());
1093 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs());
1094
1095 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1096
1097 Exp->GetCoords(xc, yc, zc);
1098
1099 for (int i = 0; i < nq; ++i)
1100 {
1101 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1102 }
1103
1104 Exp->IProductWRTBase(phys, coeffsRef);
1105 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs);
1106
1107 double epsilon = 1.0e-8;
1108 for (int i = 0; i < coeffsRef.size(); ++i)
1109 {
1110 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
1111 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
1112 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
1113 }
1114}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [20/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_MatrixFree_UniformP_Deformed_OverInt  )

Definition at line 1116 of file TestHexCollection.cpp.

1118{
1119 SpatialDomains::PointGeomSharedPtr v0(
1120 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
1121 SpatialDomains::PointGeomSharedPtr v1(
1122 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1123 SpatialDomains::PointGeomSharedPtr v2(
1124 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1125 SpatialDomains::PointGeomSharedPtr v3(
1126 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1127 SpatialDomains::PointGeomSharedPtr v4(
1128 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1129 SpatialDomains::PointGeomSharedPtr v5(
1130 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1131 SpatialDomains::PointGeomSharedPtr v6(
1132 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
1133 SpatialDomains::PointGeomSharedPtr v7(
1134 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1135
1136 SpatialDomains::HexGeomSharedPtr hexGeom =
1137 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1138
1139 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1140 Nektar::LibUtilities::eGaussLobattoLegendre;
1141 Nektar::LibUtilities::BasisType basisTypeDir1 =
1142 Nektar::LibUtilities::eModified_A;
1143 unsigned int numQuadPoints = 8;
1144 unsigned int numModes = 4;
1145 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
1146 quadPointsTypeDir1);
1147 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
1148 quadPointsKeyDir1);
1149
1150 Nektar::LocalRegions::HexExpSharedPtr Exp =
1151 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1152 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
1153
1154 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1155 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1156 basisKeyDir1, basisKeyDir1, basisKeyDir1);
1157
1158 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1159 CollExp.push_back(Exp);
1160
1161 LibUtilities::SessionReaderSharedPtr dummySession;
1162 Collections::CollectionOptimisation colOpt(dummySession, 2,
1163 Collections::eMatrixFree);
1164 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1165 Collections::Collection c(CollExp, impTypes);
1166 c.Initialise(Collections::eIProductWRTBase);
1167
1168 const int nq = Exp->GetTotPoints();
1169 Array<OneD, NekDouble> phys(nq);
1170 Array<OneD, NekDouble> coeffsRef(Exp->GetNcoeffs());
1171 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs());
1172
1173 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1174
1175 Exp->GetCoords(xc, yc, zc);
1176
1177 for (int i = 0; i < nq; ++i)
1178 {
1179 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1180 }
1181
1182 Exp->IProductWRTBase(phys, coeffsRef);
1183 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs);
1184
1185 double epsilon = 1.0e-8;
1186 for (int i = 0; i < coeffsRef.size(); ++i)
1187 {
1188 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
1189 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
1190 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
1191 }
1192}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [21/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_MatrixFree_UniformP_Undeformed  )

Definition at line 962 of file TestHexCollection.cpp.

963{
964 SpatialDomains::PointGeomSharedPtr v0(
965 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
966 SpatialDomains::PointGeomSharedPtr v1(
967 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
968 SpatialDomains::PointGeomSharedPtr v2(
969 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
970 SpatialDomains::PointGeomSharedPtr v3(
971 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
972 SpatialDomains::PointGeomSharedPtr v4(
973 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
974 SpatialDomains::PointGeomSharedPtr v5(
975 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
976 SpatialDomains::PointGeomSharedPtr v6(
977 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
978 SpatialDomains::PointGeomSharedPtr v7(
979 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
980
981 SpatialDomains::HexGeomSharedPtr hexGeom =
982 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
983
984 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
985 Nektar::LibUtilities::eGaussLobattoLegendre;
986 Nektar::LibUtilities::BasisType basisTypeDir1 =
987 Nektar::LibUtilities::eModified_A;
988 unsigned int numQuadPoints = 5;
989 unsigned int numModes = 4;
990 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
991 quadPointsTypeDir1);
992 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
993 quadPointsKeyDir1);
994
995 Nektar::LocalRegions::HexExpSharedPtr Exp =
996 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
997 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
998
999 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1000 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1001 basisKeyDir1, basisKeyDir1, basisKeyDir1);
1002
1003 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1004 CollExp.push_back(Exp);
1005
1006 LibUtilities::SessionReaderSharedPtr dummySession;
1007 Collections::CollectionOptimisation colOpt(dummySession, 2,
1008 Collections::eMatrixFree);
1009 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1010 Collections::Collection c(CollExp, impTypes);
1011 c.Initialise(Collections::eIProductWRTBase);
1012
1013 const int nq = Exp->GetTotPoints();
1014 Array<OneD, NekDouble> phys(nq);
1015 Array<OneD, NekDouble> coeffsRef(Exp->GetNcoeffs());
1016 Array<OneD, NekDouble> coeffs(Exp->GetNcoeffs());
1017
1018 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1019
1020 Exp->GetCoords(xc, yc, zc);
1021
1022 for (int i = 0; i < nq; ++i)
1023 {
1024 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1025 }
1026
1027 Exp->IProductWRTBase(phys, coeffsRef);
1028 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs);
1029
1030 double epsilon = 1.0e-8;
1031 for (int i = 0; i < coeffsRef.size(); ++i)
1032 {
1033 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
1034 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
1035 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
1036 }
1037}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [22/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_NoCollection_VariableP  )

Definition at line 1276 of file TestHexCollection.cpp.

1277{
1278 SpatialDomains::PointGeomSharedPtr v0(
1279 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1280 SpatialDomains::PointGeomSharedPtr v1(
1281 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1282 SpatialDomains::PointGeomSharedPtr v2(
1283 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1284 SpatialDomains::PointGeomSharedPtr v3(
1285 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1286 SpatialDomains::PointGeomSharedPtr v4(
1287 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1288 SpatialDomains::PointGeomSharedPtr v5(
1289 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1290 SpatialDomains::PointGeomSharedPtr v6(
1291 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1292 SpatialDomains::PointGeomSharedPtr v7(
1293 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1294
1295 SpatialDomains::HexGeomSharedPtr hexGeom =
1296 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1297
1298 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1299 Nektar::LibUtilities::eGaussLobattoLegendre;
1300 Nektar::LibUtilities::BasisType basisTypeDir1 =
1301 Nektar::LibUtilities::eModified_A;
1302 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1303 quadPointsTypeDir1);
1304 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1305 quadPointsTypeDir1);
1306 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
1307 quadPointsTypeDir1);
1308 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1309 quadPointsKeyDir1);
1310 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1311 quadPointsKeyDir2);
1312 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1313 quadPointsKeyDir3);
1314
1315 Nektar::LocalRegions::HexExpSharedPtr Exp =
1316 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1317 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1318
1319 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1320 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1321 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1322
1323 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1324 CollExp.push_back(Exp);
1325
1326 LibUtilities::SessionReaderSharedPtr dummySession;
1327 Collections::CollectionOptimisation colOpt(dummySession, 3,
1328 Collections::eNoCollection);
1329 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1330 Collections::Collection c(CollExp, impTypes);
1331 c.Initialise(Collections::eIProductWRTBase);
1332
1333 const int nq = Exp->GetTotPoints();
1334 Array<OneD, NekDouble> phys(nq);
1335 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1336 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1337
1338 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1339
1340 Exp->GetCoords(xc, yc, zc);
1341
1342 for (int i = 0; i < nq; ++i)
1343 {
1344 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1345 }
1346
1347 Exp->IProductWRTBase(phys, coeffs1);
1348 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1349 c.Initialise(Collections::eIProductWRTBase);
1350
1351 double epsilon = 1.0e-8;
1352 for (int i = 0; i < coeffs1.size(); ++i)
1353 {
1354 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1355 }
1356}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eNoCollection, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [23/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_StdMat_UniformP  )

Definition at line 888 of file TestHexCollection.cpp.

889{
890 SpatialDomains::PointGeomSharedPtr v0(
891 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
892 SpatialDomains::PointGeomSharedPtr v1(
893 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
894 SpatialDomains::PointGeomSharedPtr v2(
895 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
896 SpatialDomains::PointGeomSharedPtr v3(
897 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
898 SpatialDomains::PointGeomSharedPtr v4(
899 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
900 SpatialDomains::PointGeomSharedPtr v5(
901 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
902 SpatialDomains::PointGeomSharedPtr v6(
903 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
904 SpatialDomains::PointGeomSharedPtr v7(
905 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
906
907 SpatialDomains::HexGeomSharedPtr hexGeom =
908 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
909
910 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
911 Nektar::LibUtilities::eGaussLobattoLegendre;
912 Nektar::LibUtilities::BasisType basisTypeDir1 =
913 Nektar::LibUtilities::eModified_A;
914 unsigned int numQuadPoints = 6;
915 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
916 quadPointsTypeDir1);
917 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
918 quadPointsKeyDir1);
919
920 Nektar::LocalRegions::HexExpSharedPtr Exp =
921 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
922 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
923
924 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
925 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
926 basisKeyDir1, basisKeyDir1, basisKeyDir1);
927
928 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
929 CollExp.push_back(Exp);
930
931 LibUtilities::SessionReaderSharedPtr dummySession;
932 Collections::CollectionOptimisation colOpt(dummySession, 3,
933 Collections::eStdMat);
934 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
935 Collections::Collection c(CollExp, impTypes);
936 c.Initialise(Collections::eIProductWRTBase);
937
938 const int nq = Exp->GetTotPoints();
939 Array<OneD, NekDouble> phys(nq);
940 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
941 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
942
943 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
944
945 Exp->GetCoords(xc, yc, zc);
946
947 for (int i = 0; i < nq; ++i)
948 {
949 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
950 }
951
952 Exp->IProductWRTBase(phys, coeffs1);
953 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
954
955 double epsilon = 1.0e-8;
956 for (int i = 0; i < coeffs1.size(); ++i)
957 {
958 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
959 }
960}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [24/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_StdMat_VariableP  )

Definition at line 1194 of file TestHexCollection.cpp.

1195{
1196 SpatialDomains::PointGeomSharedPtr v0(
1197 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1198 SpatialDomains::PointGeomSharedPtr v1(
1199 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1200 SpatialDomains::PointGeomSharedPtr v2(
1201 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1202 SpatialDomains::PointGeomSharedPtr v3(
1203 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1204 SpatialDomains::PointGeomSharedPtr v4(
1205 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1206 SpatialDomains::PointGeomSharedPtr v5(
1207 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1208 SpatialDomains::PointGeomSharedPtr v6(
1209 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1210 SpatialDomains::PointGeomSharedPtr v7(
1211 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1212
1213 SpatialDomains::HexGeomSharedPtr hexGeom =
1214 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1215
1216 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1217 Nektar::LibUtilities::eGaussLobattoLegendre;
1218 Nektar::LibUtilities::BasisType basisTypeDir1 =
1219 Nektar::LibUtilities::eModified_A;
1220 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1221 quadPointsTypeDir1);
1222 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1223 quadPointsTypeDir1);
1224 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
1225 quadPointsTypeDir1);
1226 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1227 quadPointsKeyDir1);
1228 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1229 quadPointsKeyDir2);
1230 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1231 quadPointsKeyDir3);
1232
1233 Nektar::LocalRegions::HexExpSharedPtr Exp =
1234 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1235 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1236
1237 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1238 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1239 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1240
1241 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1242 CollExp.push_back(Exp);
1243
1244 LibUtilities::SessionReaderSharedPtr dummySession;
1245 Collections::CollectionOptimisation colOpt(dummySession, 3,
1246 Collections::eStdMat);
1247 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1248 Collections::Collection c(CollExp, impTypes);
1249 c.Initialise(Collections::eIProductWRTBase);
1250
1251 const int nq = Exp->GetTotPoints();
1252 Array<OneD, NekDouble> phys(nq);
1253 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1254 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1255
1256 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1257
1258 Exp->GetCoords(xc, yc, zc);
1259
1260 for (int i = 0; i < nq; ++i)
1261 {
1262 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1263 }
1264
1265 Exp->IProductWRTBase(phys, coeffs1);
1266 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1267 c.Initialise(Collections::eIProductWRTBase);
1268
1269 double epsilon = 1.0e-8;
1270 for (int i = 0; i < coeffs1.size(); ++i)
1271 {
1272 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1273 }
1274}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [25/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_StdMat_VariableP_MultiElmt  )

Definition at line 1601 of file TestHexCollection.cpp.

1602{
1603 SpatialDomains::PointGeomSharedPtr v0(
1604 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1605 SpatialDomains::PointGeomSharedPtr v1(
1606 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1607 SpatialDomains::PointGeomSharedPtr v2(
1608 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1609 SpatialDomains::PointGeomSharedPtr v3(
1610 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1611 SpatialDomains::PointGeomSharedPtr v4(
1612 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1613 SpatialDomains::PointGeomSharedPtr v5(
1614 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1615 SpatialDomains::PointGeomSharedPtr v6(
1616 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1617 SpatialDomains::PointGeomSharedPtr v7(
1618 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1619
1620 SpatialDomains::HexGeomSharedPtr hexGeom =
1621 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1622
1623 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1624 Nektar::LibUtilities::eGaussLobattoLegendre;
1625 Nektar::LibUtilities::BasisType basisTypeDir1 =
1626 Nektar::LibUtilities::eModified_A;
1627 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1628 quadPointsTypeDir1);
1629 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1630 quadPointsTypeDir1);
1631 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
1632 quadPointsTypeDir1);
1633 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1634 quadPointsKeyDir1);
1635 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1636 quadPointsKeyDir2);
1637 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1638 quadPointsKeyDir3);
1639
1640 Nektar::LocalRegions::HexExpSharedPtr Exp =
1641 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1642 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1643
1644 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1645 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1646 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1647
1648 int nelmts = 10;
1649
1650 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1651 for (int i = 0; i < nelmts; ++i)
1652 {
1653 CollExp.push_back(Exp);
1654 }
1655
1656 LibUtilities::SessionReaderSharedPtr dummySession;
1657 Collections::CollectionOptimisation colOpt(dummySession, 3,
1658 Collections::eStdMat);
1659 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1660 Collections::Collection c(CollExp, impTypes);
1661 c.Initialise(Collections::eIProductWRTBase);
1662
1663 const int nq = Exp->GetTotPoints();
1664 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
1665 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
1666 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
1667
1668 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1669
1670 Exp->GetCoords(xc, yc, zc);
1671
1672 for (int i = 0; i < nq; ++i)
1673 {
1674 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1675 }
1676 Exp->IProductWRTBase(phys, coeffs1);
1677
1678 for (int i = 1; i < nelmts; ++i)
1679 {
1680 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
1681 Exp->IProductWRTBase(phys + i * nq,
1682 tmp = coeffs1 + i * Exp->GetNcoeffs());
1683 }
1684
1685 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1686
1687 double epsilon = 1.0e-8;
1688 for (int i = 0; i < coeffs1.size(); ++i)
1689 {
1690 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1691 }
1692}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [26/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_UniformP  )

Definition at line 1787 of file TestHexCollection.cpp.

1788{
1789 SpatialDomains::PointGeomSharedPtr v0(
1790 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
1791 SpatialDomains::PointGeomSharedPtr v1(
1792 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1793 SpatialDomains::PointGeomSharedPtr v2(
1794 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1795 SpatialDomains::PointGeomSharedPtr v3(
1796 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1797 SpatialDomains::PointGeomSharedPtr v4(
1798 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1799 SpatialDomains::PointGeomSharedPtr v5(
1800 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1801 SpatialDomains::PointGeomSharedPtr v6(
1802 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1803 SpatialDomains::PointGeomSharedPtr v7(
1804 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1805
1806 SpatialDomains::HexGeomSharedPtr hexGeom =
1807 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1808
1809 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1810 Nektar::LibUtilities::eGaussLobattoLegendre;
1811 Nektar::LibUtilities::BasisType basisTypeDir1 =
1812 Nektar::LibUtilities::eModified_A;
1813 unsigned int numQuadPoints = 6;
1814 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
1815 quadPointsTypeDir1);
1816 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1817 quadPointsKeyDir1);
1818
1819 Nektar::LocalRegions::HexExpSharedPtr Exp =
1820 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1821 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
1822
1823 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1824 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1825 basisKeyDir1, basisKeyDir1, basisKeyDir1);
1826
1827 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1828 CollExp.push_back(Exp);
1829
1830 LibUtilities::SessionReaderSharedPtr dummySession;
1831 Collections::CollectionOptimisation colOpt(dummySession, 3,
1832 Collections::eSumFac);
1833 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1834 Collections::Collection c(CollExp, impTypes);
1835 c.Initialise(Collections::eIProductWRTBase);
1836
1837 const int nq = Exp->GetTotPoints();
1838 Array<OneD, NekDouble> phys(nq);
1839 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1840 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1841
1842 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1843
1844 Exp->GetCoords(xc, yc, zc);
1845
1846 for (int i = 0; i < nq; ++i)
1847 {
1848 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1849 }
1850
1851 Exp->IProductWRTBase(phys, coeffs1);
1852 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1853
1854 double epsilon = 1.0e-6;
1855 for (int i = 0; i < coeffs1.size(); ++i)
1856 {
1857 // clamp values below 1e-16 to zero
1858 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-16) ? 0.0 : coeffs1[i];
1859 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-16) ? 0.0 : coeffs2[i];
1860 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1861 }
1862}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [27/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_UniformP_MultiElmt  )

Definition at line 1948 of file TestHexCollection.cpp.

1949{
1950 SpatialDomains::PointGeomSharedPtr v0(
1951 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1952 SpatialDomains::PointGeomSharedPtr v1(
1953 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1954 SpatialDomains::PointGeomSharedPtr v2(
1955 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1956 SpatialDomains::PointGeomSharedPtr v3(
1957 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1958 SpatialDomains::PointGeomSharedPtr v4(
1959 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1960 SpatialDomains::PointGeomSharedPtr v5(
1961 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1962 SpatialDomains::PointGeomSharedPtr v6(
1963 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1964 SpatialDomains::PointGeomSharedPtr v7(
1965 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1966
1967 SpatialDomains::HexGeomSharedPtr hexGeom =
1968 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1969
1970 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1971 Nektar::LibUtilities::eGaussLobattoLegendre;
1972 Nektar::LibUtilities::BasisType basisTypeDir1 =
1973 Nektar::LibUtilities::eModified_A;
1974 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1975 quadPointsTypeDir1);
1976 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1977 quadPointsKeyDir1);
1978
1979 Nektar::LocalRegions::HexExpSharedPtr Exp =
1980 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1981 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
1982
1983 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1984 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1985 basisKeyDir1, basisKeyDir1, basisKeyDir1);
1986
1987 int nelmts = 10;
1988
1989 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1990 for (int i = 0; i < nelmts; ++i)
1991 {
1992 CollExp.push_back(Exp);
1993 }
1994
1995 LibUtilities::SessionReaderSharedPtr dummySession;
1996 Collections::CollectionOptimisation colOpt(dummySession, 3,
1997 Collections::eSumFac);
1998 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1999 Collections::Collection c(CollExp, impTypes);
2000 c.Initialise(Collections::eIProductWRTBase);
2001
2002 const int nq = Exp->GetTotPoints();
2003 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
2004 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
2005 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
2006
2007 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2008
2009 Exp->GetCoords(xc, yc, zc);
2010
2011 for (int i = 0; i < nq; ++i)
2012 {
2013 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2014 }
2015 Exp->IProductWRTBase(phys, coeffs1);
2016
2017 for (int i = 1; i < nelmts; ++i)
2018 {
2019 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
2020 Exp->IProductWRTBase(phys + i * nq,
2021 tmp = coeffs1 + i * Exp->GetNcoeffs());
2022 }
2023 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
2024
2025 double epsilon = 1.0e-6;
2026 for (int i = 0; i < coeffs1.size(); ++i)
2027 {
2028 // clamp values below 1e-16 to zero
2029 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-16) ? 0.0 : coeffs1[i];
2030 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-16) ? 0.0 : coeffs2[i];
2031 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
2032 }
2033}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [28/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP  )

Definition at line 1864 of file TestHexCollection.cpp.

1865{
1866 SpatialDomains::PointGeomSharedPtr v0(
1867 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1868 SpatialDomains::PointGeomSharedPtr v1(
1869 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1870 SpatialDomains::PointGeomSharedPtr v2(
1871 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1872 SpatialDomains::PointGeomSharedPtr v3(
1873 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1874 SpatialDomains::PointGeomSharedPtr v4(
1875 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1876 SpatialDomains::PointGeomSharedPtr v5(
1877 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1878 SpatialDomains::PointGeomSharedPtr v6(
1879 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1880 SpatialDomains::PointGeomSharedPtr v7(
1881 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1882
1883 SpatialDomains::HexGeomSharedPtr hexGeom =
1884 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1885
1886 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1887 Nektar::LibUtilities::eGaussLobattoLegendre;
1888 Nektar::LibUtilities::BasisType basisTypeDir1 =
1889 Nektar::LibUtilities::eModified_A;
1890 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1891 quadPointsTypeDir1);
1892 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1893 quadPointsTypeDir1);
1894 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
1895 quadPointsTypeDir1);
1896 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1897 quadPointsKeyDir1);
1898 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1899 quadPointsKeyDir2);
1900 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1901 quadPointsKeyDir3);
1902
1903 Nektar::LocalRegions::HexExpSharedPtr Exp =
1904 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1905 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1906
1907 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1908 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1909 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1910
1911 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1912 CollExp.push_back(Exp);
1913
1914 LibUtilities::SessionReaderSharedPtr dummySession;
1915 Collections::CollectionOptimisation colOpt(dummySession, 3,
1916 Collections::eSumFac);
1917 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1918 Collections::Collection c(CollExp, impTypes);
1919 c.Initialise(Collections::eIProductWRTBase);
1920
1921 const int nq = Exp->GetTotPoints();
1922 Array<OneD, NekDouble> phys(nq);
1923 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1924 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1925
1926 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1927
1928 Exp->GetCoords(xc, yc, zc);
1929
1930 for (int i = 0; i < nq; ++i)
1931 {
1932 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1933 }
1934
1935 Exp->IProductWRTBase(phys, coeffs1);
1936 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1937
1938 double epsilon = 1.0e-6;
1939 for (int i = 0; i < coeffs1.size(); ++i)
1940 {
1941 // clamp values below 1e-16 to zero
1942 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-16) ? 0.0 : coeffs1[i];
1943 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-16) ? 0.0 : coeffs2[i];
1944 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1945 }
1946}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [29/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_CollAll  )

Definition at line 1358 of file TestHexCollection.cpp.

1359{
1360 SpatialDomains::PointGeomSharedPtr v0(
1361 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1362 SpatialDomains::PointGeomSharedPtr v1(
1363 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1364 SpatialDomains::PointGeomSharedPtr v2(
1365 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1366 SpatialDomains::PointGeomSharedPtr v3(
1367 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1368 SpatialDomains::PointGeomSharedPtr v4(
1369 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1370 SpatialDomains::PointGeomSharedPtr v5(
1371 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1372 SpatialDomains::PointGeomSharedPtr v6(
1373 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1374 SpatialDomains::PointGeomSharedPtr v7(
1375 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1376
1377 SpatialDomains::HexGeomSharedPtr hexGeom =
1378 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1379
1380 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1381 Nektar::LibUtilities::eGaussLobattoLegendre;
1382 Nektar::LibUtilities::BasisType basisTypeDir1 =
1383 Nektar::LibUtilities::eGLL_Lagrange;
1384 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(4,
1385 quadPointsTypeDir1);
1386 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
1387 quadPointsTypeDir1);
1388 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
1389 quadPointsTypeDir1);
1390 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1391 quadPointsKeyDir1);
1392 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1393 quadPointsKeyDir2);
1394 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1395 quadPointsKeyDir3);
1396
1397 Nektar::LocalRegions::HexExpSharedPtr Exp =
1398 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1399 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1400
1401 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1402 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1403 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1404
1405 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1406 CollExp.push_back(Exp);
1407
1408 LibUtilities::SessionReaderSharedPtr dummySession;
1409 Collections::CollectionOptimisation colOpt(dummySession, 3,
1410 Collections::eSumFac);
1411 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1412 Collections::Collection c(CollExp, impTypes);
1413 c.Initialise(Collections::eIProductWRTBase);
1414
1415 const int nq = Exp->GetTotPoints();
1416 Array<OneD, NekDouble> phys(nq);
1417 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1418 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1419
1420 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1421
1422 Exp->GetCoords(xc, yc, zc);
1423
1424 for (int i = 0; i < nq; ++i)
1425 {
1426 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1427 }
1428
1429 Exp->IProductWRTBase(phys, coeffs1);
1430 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1431
1432 double epsilon = 1.0e-8;
1433 for (int i = 0; i < coeffs1.size(); ++i)
1434 {
1435 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1436 }
1437}
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:58

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [30/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_CollDir02  )

Definition at line 1439 of file TestHexCollection.cpp.

1440{
1441 SpatialDomains::PointGeomSharedPtr v0(
1442 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1443 SpatialDomains::PointGeomSharedPtr v1(
1444 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1445 SpatialDomains::PointGeomSharedPtr v2(
1446 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1447 SpatialDomains::PointGeomSharedPtr v3(
1448 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1449 SpatialDomains::PointGeomSharedPtr v4(
1450 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1451 SpatialDomains::PointGeomSharedPtr v5(
1452 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1453 SpatialDomains::PointGeomSharedPtr v6(
1454 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1455 SpatialDomains::PointGeomSharedPtr v7(
1456 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1457
1458 SpatialDomains::HexGeomSharedPtr hexGeom =
1459 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1460
1461 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1462 Nektar::LibUtilities::eGaussLobattoLegendre;
1463 Nektar::LibUtilities::BasisType basisTypeDir1 =
1464 Nektar::LibUtilities::eGLL_Lagrange;
1465 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(4,
1466 quadPointsTypeDir1);
1467 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
1468 quadPointsTypeDir1);
1469 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
1470 quadPointsTypeDir1);
1471 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1472 quadPointsKeyDir1);
1473 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1474 quadPointsKeyDir2);
1475 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1476 quadPointsKeyDir3);
1477
1478 Nektar::LocalRegions::HexExpSharedPtr Exp =
1479 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1480 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1481
1482 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1483 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1484 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1485
1486 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1487 CollExp.push_back(Exp);
1488
1489 LibUtilities::SessionReaderSharedPtr dummySession;
1490 Collections::CollectionOptimisation colOpt(dummySession, 3,
1491 Collections::eSumFac);
1492 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1493 Collections::Collection c(CollExp, impTypes);
1494 c.Initialise(Collections::eIProductWRTBase);
1495
1496 const int nq = Exp->GetTotPoints();
1497 Array<OneD, NekDouble> phys(nq);
1498 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1499 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1500
1501 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1502
1503 Exp->GetCoords(xc, yc, zc);
1504
1505 for (int i = 0; i < nq; ++i)
1506 {
1507 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1508 }
1509
1510 Exp->IProductWRTBase(phys, coeffs1);
1511 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1512
1513 double epsilon = 1.0e-8;
1514 for (int i = 0; i < coeffs1.size(); ++i)
1515 {
1516 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1517 }
1518}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [31/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_CollDir12  )

Definition at line 1520 of file TestHexCollection.cpp.

1521{
1522 SpatialDomains::PointGeomSharedPtr v0(
1523 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
1524 SpatialDomains::PointGeomSharedPtr v1(
1525 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
1526 SpatialDomains::PointGeomSharedPtr v2(
1527 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
1528 SpatialDomains::PointGeomSharedPtr v3(
1529 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
1530 SpatialDomains::PointGeomSharedPtr v4(
1531 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
1532 SpatialDomains::PointGeomSharedPtr v5(
1533 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
1534 SpatialDomains::PointGeomSharedPtr v6(
1535 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
1536 SpatialDomains::PointGeomSharedPtr v7(
1537 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
1538
1539 SpatialDomains::HexGeomSharedPtr hexGeom =
1540 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
1541
1542 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
1543 Nektar::LibUtilities::eGaussLobattoLegendre;
1544 Nektar::LibUtilities::BasisType basisTypeDir1 =
1545 Nektar::LibUtilities::eGLL_Lagrange;
1546 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
1547 quadPointsTypeDir1);
1548 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
1549 quadPointsTypeDir1);
1550 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
1551 quadPointsTypeDir1);
1552 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
1553 quadPointsKeyDir1);
1554 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
1555 quadPointsKeyDir2);
1556 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
1557 quadPointsKeyDir3);
1558
1559 Nektar::LocalRegions::HexExpSharedPtr Exp =
1560 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
1561 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
1562
1563 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
1564 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
1565 basisKeyDir1, basisKeyDir2, basisKeyDir3);
1566
1567 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
1568 CollExp.push_back(Exp);
1569
1570 LibUtilities::SessionReaderSharedPtr dummySession;
1571 Collections::CollectionOptimisation colOpt(dummySession, 3,
1572 Collections::eSumFac);
1573 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
1574 Collections::Collection c(CollExp, impTypes);
1575 c.Initialise(Collections::eIProductWRTBase);
1576
1577 const int nq = Exp->GetTotPoints();
1578 Array<OneD, NekDouble> phys(nq);
1579 Array<OneD, NekDouble> coeffs1(Exp->GetNcoeffs());
1580 Array<OneD, NekDouble> coeffs2(Exp->GetNcoeffs());
1581
1582 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
1583
1584 Exp->GetCoords(xc, yc, zc);
1585
1586 for (int i = 0; i < nq; ++i)
1587 {
1588 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
1589 }
1590
1591 Exp->IProductWRTBase(phys, coeffs1);
1592 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
1593
1594 double epsilon = 1.0e-8;
1595 for (int i = 0; i < coeffs1.size(); ++i)
1596 {
1597 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
1598 }
1599}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [32/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_MultiElmt  )

Definition at line 2035 of file TestHexCollection.cpp.

2036{
2037 SpatialDomains::PointGeomSharedPtr v0(
2038 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2039 SpatialDomains::PointGeomSharedPtr v1(
2040 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2041 SpatialDomains::PointGeomSharedPtr v2(
2042 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2043 SpatialDomains::PointGeomSharedPtr v3(
2044 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2045 SpatialDomains::PointGeomSharedPtr v4(
2046 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2047 SpatialDomains::PointGeomSharedPtr v5(
2048 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2049 SpatialDomains::PointGeomSharedPtr v6(
2050 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2051 SpatialDomains::PointGeomSharedPtr v7(
2052 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2053
2054 SpatialDomains::HexGeomSharedPtr hexGeom =
2055 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2056
2057 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2058 Nektar::LibUtilities::eGaussLobattoLegendre;
2059 Nektar::LibUtilities::BasisType basisTypeDir1 =
2060 Nektar::LibUtilities::eModified_A;
2061 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
2062 quadPointsTypeDir1);
2063 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(7,
2064 quadPointsTypeDir1);
2065 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(9,
2066 quadPointsTypeDir1);
2067 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2068 quadPointsKeyDir1);
2069 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2070 quadPointsKeyDir2);
2071 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2072 quadPointsKeyDir3);
2073
2074 Nektar::LocalRegions::HexExpSharedPtr Exp =
2075 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2076 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2077
2078 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2079 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2080 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2081
2082 int nelmts = 10;
2083
2084 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2085 for (int i = 0; i < nelmts; ++i)
2086 CollExp.push_back(Exp);
2087
2088 LibUtilities::SessionReaderSharedPtr dummySession;
2089 Collections::CollectionOptimisation colOpt(dummySession, 3,
2090 Collections::eSumFac);
2091 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2092 Collections::Collection c(CollExp, impTypes);
2093 c.Initialise(Collections::eIProductWRTBase);
2094
2095 const int nq = Exp->GetTotPoints();
2096 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
2097 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
2098 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
2099
2100 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2101
2102 Exp->GetCoords(xc, yc, zc);
2103
2104 for (int i = 0; i < nq; ++i)
2105 {
2106 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2107 }
2108 Exp->IProductWRTBase(phys, coeffs1);
2109
2110 for (int i = 1; i < nelmts; ++i)
2111 {
2112 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
2113 Exp->IProductWRTBase(phys + i * nq,
2114 tmp = coeffs1 + i * Exp->GetNcoeffs());
2115 }
2116 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
2117
2118 double epsilon = 1.0e-4;
2119 for (int i = 0; i < coeffs1.size(); ++i)
2120 {
2121 // clamp values below 1e-14 to zero
2122 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
2123 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
2124 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
2125 }
2126}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [33/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_MultiElmt_CollDir02  )

Definition at line 2128 of file TestHexCollection.cpp.

2130{
2131 SpatialDomains::PointGeomSharedPtr v0(
2132 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2133 SpatialDomains::PointGeomSharedPtr v1(
2134 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2135 SpatialDomains::PointGeomSharedPtr v2(
2136 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2137 SpatialDomains::PointGeomSharedPtr v3(
2138 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2139 SpatialDomains::PointGeomSharedPtr v4(
2140 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2141 SpatialDomains::PointGeomSharedPtr v5(
2142 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2143 SpatialDomains::PointGeomSharedPtr v6(
2144 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2145 SpatialDomains::PointGeomSharedPtr v7(
2146 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2147
2148 SpatialDomains::HexGeomSharedPtr hexGeom =
2149 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2150
2151 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2152 Nektar::LibUtilities::eGaussLobattoLegendre;
2153 Nektar::LibUtilities::BasisType basisTypeDir1 =
2154 Nektar::LibUtilities::eGLL_Lagrange;
2155 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(4,
2156 quadPointsTypeDir1);
2157 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
2158 quadPointsTypeDir1);
2159 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
2160 quadPointsTypeDir1);
2161 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2162 quadPointsKeyDir1);
2163 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2164 quadPointsKeyDir2);
2165 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2166 quadPointsKeyDir3);
2167
2168 Nektar::LocalRegions::HexExpSharedPtr Exp =
2169 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2170 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2171
2172 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2173 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2174 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2175
2176 int nelmts = 10;
2177
2178 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2179 for (int i = 0; i < nelmts; ++i)
2180 CollExp.push_back(Exp);
2181
2182 LibUtilities::SessionReaderSharedPtr dummySession;
2183 Collections::CollectionOptimisation colOpt(dummySession, 3,
2184 Collections::eSumFac);
2185 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2186 Collections::Collection c(CollExp, impTypes);
2187 c.Initialise(Collections::eIProductWRTBase);
2188
2189 const int nq = Exp->GetTotPoints();
2190 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
2191 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
2192 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
2193
2194 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2195
2196 Exp->GetCoords(xc, yc, zc);
2197
2198 for (int i = 0; i < nq; ++i)
2199 {
2200 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2201 }
2202 Exp->IProductWRTBase(phys, coeffs1);
2203
2204 for (int i = 1; i < nelmts; ++i)
2205 {
2206 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
2207 Exp->IProductWRTBase(phys + i * nq,
2208 tmp = coeffs1 + i * Exp->GetNcoeffs());
2209 }
2210 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
2211
2212 double epsilon = 1.0e-4;
2213 for (int i = 0; i < coeffs1.size(); ++i)
2214 {
2215 // clamp values below 1e-14 to zero
2216 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
2217 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
2218 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
2219 }
2220}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [34/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTBase_SumFac_VariableP_MultiElmt_CollDir12  )

Definition at line 2222 of file TestHexCollection.cpp.

2224{
2225 SpatialDomains::PointGeomSharedPtr v0(
2226 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2227 SpatialDomains::PointGeomSharedPtr v1(
2228 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2229 SpatialDomains::PointGeomSharedPtr v2(
2230 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2231 SpatialDomains::PointGeomSharedPtr v3(
2232 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2233 SpatialDomains::PointGeomSharedPtr v4(
2234 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2235 SpatialDomains::PointGeomSharedPtr v5(
2236 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2237 SpatialDomains::PointGeomSharedPtr v6(
2238 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2239 SpatialDomains::PointGeomSharedPtr v7(
2240 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2241
2242 SpatialDomains::HexGeomSharedPtr hexGeom =
2243 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2244
2245 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2246 Nektar::LibUtilities::eGaussLobattoLegendre;
2247 Nektar::LibUtilities::BasisType basisTypeDir1 =
2248 Nektar::LibUtilities::eGLL_Lagrange;
2249 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
2250 quadPointsTypeDir1);
2251 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
2252 quadPointsTypeDir1);
2253 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
2254 quadPointsTypeDir1);
2255 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2256 quadPointsKeyDir1);
2257 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2258 quadPointsKeyDir2);
2259 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2260 quadPointsKeyDir3);
2261
2262 Nektar::LocalRegions::HexExpSharedPtr Exp =
2263 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2264 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2265
2266 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2267 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2268 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2269
2270 int nelmts = 10;
2271
2272 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2273 for (int i = 0; i < nelmts; ++i)
2274 CollExp.push_back(Exp);
2275
2276 LibUtilities::SessionReaderSharedPtr dummySession;
2277 Collections::CollectionOptimisation colOpt(dummySession, 3,
2278 Collections::eSumFac);
2279 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2280 Collections::Collection c(CollExp, impTypes);
2281 c.Initialise(Collections::eIProductWRTBase);
2282
2283 const int nq = Exp->GetTotPoints();
2284 Array<OneD, NekDouble> phys(nelmts * nq), tmp;
2285 Array<OneD, NekDouble> coeffs1(nelmts * Exp->GetNcoeffs());
2286 Array<OneD, NekDouble> coeffs2(nelmts * Exp->GetNcoeffs());
2287
2288 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2289
2290 Exp->GetCoords(xc, yc, zc);
2291
2292 for (int i = 0; i < nq; ++i)
2293 {
2294 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2295 }
2296 Exp->IProductWRTBase(phys, coeffs1);
2297
2298 for (int i = 1; i < nelmts; ++i)
2299 {
2300 Vmath::Vcopy(nq, &phys[0], 1, &phys[i * nq], 1);
2301 Exp->IProductWRTBase(phys + i * nq,
2302 tmp = coeffs1 + i * Exp->GetNcoeffs());
2303 }
2304 c.ApplyOperator(Collections::eIProductWRTBase, phys, coeffs2);
2305
2306 double epsilon = 1.0e-4;
2307 for (int i = 0; i < coeffs1.size(); ++i)
2308 {
2309 // clamp values below 1e-14 to zero
2310 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
2311 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
2312 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
2313 }
2314}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::Collections::eIProductWRTBase, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [35/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_Iterperexp_UniformP  )

Definition at line 3069 of file TestHexCollection.cpp.

3070{
3071 SpatialDomains::PointGeomSharedPtr v0(
3072 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3073 SpatialDomains::PointGeomSharedPtr v1(
3074 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3075 SpatialDomains::PointGeomSharedPtr v2(
3076 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3077 SpatialDomains::PointGeomSharedPtr v3(
3078 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3079 SpatialDomains::PointGeomSharedPtr v4(
3080 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3081 SpatialDomains::PointGeomSharedPtr v5(
3082 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3083 SpatialDomains::PointGeomSharedPtr v6(
3084 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3085 SpatialDomains::PointGeomSharedPtr v7(
3086 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3087
3088 SpatialDomains::HexGeomSharedPtr hexGeom =
3089 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3090
3091 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3092 Nektar::LibUtilities::eGaussLobattoLegendre;
3093 Nektar::LibUtilities::BasisType basisTypeDir1 =
3094 Nektar::LibUtilities::eModified_A;
3095 unsigned int numQuadPoints = 6;
3096 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3097 quadPointsTypeDir1);
3098 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3099 quadPointsKeyDir1);
3100
3101 Nektar::LocalRegions::HexExpSharedPtr Exp =
3102 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3103 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3104
3105 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3106 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3107 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3108
3109 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3110 CollExp.push_back(Exp);
3111
3112 LibUtilities::SessionReaderSharedPtr dummySession;
3113 Collections::CollectionOptimisation colOpt(dummySession, 3,
3114 Collections::eIterPerExp);
3115 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3116 Collections::Collection c(CollExp, impTypes);
3117 c.Initialise(Collections::eIProductWRTDerivBase);
3118
3119 const int nq = Exp->GetTotPoints();
3120 const int nm = Exp->GetNcoeffs();
3121 Array<OneD, NekDouble> phys1(nq, 0.0);
3122 Array<OneD, NekDouble> phys2(nq, 0.0);
3123 Array<OneD, NekDouble> phys3(nq, 0.0);
3124 Array<OneD, NekDouble> coeffs1(nm, 0.0);
3125 Array<OneD, NekDouble> coeffs2(nm, 0.0);
3126
3127 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3128
3129 Exp->GetCoords(xc, yc, zc);
3130
3131 for (int i = 0; i < nq; ++i)
3132 {
3133 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3134 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3135 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3136 }
3137
3138 // Standard routines
3139 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
3140 Exp->IProductWRTDerivBase(1, phys2, coeffs2);
3141 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3142 Exp->IProductWRTDerivBase(2, phys3, coeffs2);
3143 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3144
3145 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3146 coeffs2);
3147
3148 double epsilon = 1.0e-8;
3149 for (int i = 0; i < nm; ++i)
3150 {
3151 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3152 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3153 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3154 }
3155}
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.cpp:354

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [36/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_IterPerExp_VariableP_MultiElmt  )

Definition at line 3425 of file TestHexCollection.cpp.

3426{
3427 SpatialDomains::PointGeomSharedPtr v0(
3428 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3429 SpatialDomains::PointGeomSharedPtr v1(
3430 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3431 SpatialDomains::PointGeomSharedPtr v2(
3432 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3433 SpatialDomains::PointGeomSharedPtr v3(
3434 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3435 SpatialDomains::PointGeomSharedPtr v4(
3436 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3437 SpatialDomains::PointGeomSharedPtr v5(
3438 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3439 SpatialDomains::PointGeomSharedPtr v6(
3440 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3441 SpatialDomains::PointGeomSharedPtr v7(
3442 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3443
3444 SpatialDomains::HexGeomSharedPtr hexGeom =
3445 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3446
3447 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3448 Nektar::LibUtilities::eGaussLobattoLegendre;
3449 Nektar::LibUtilities::BasisType basisTypeDir1 =
3450 Nektar::LibUtilities::eModified_A;
3451 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
3452 quadPointsTypeDir1);
3453 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
3454 quadPointsTypeDir1);
3455 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
3456 quadPointsTypeDir1);
3457 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3458 quadPointsKeyDir1);
3459 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
3460 quadPointsKeyDir2);
3461 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
3462 quadPointsKeyDir3);
3463
3464 Nektar::LocalRegions::HexExpSharedPtr Exp =
3465 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3466 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
3467
3468 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3469 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3470 basisKeyDir1, basisKeyDir2, basisKeyDir3);
3471
3472 int nelmts = 10;
3473
3474 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3475 for (int i = 0; i < nelmts; ++i)
3476 {
3477 CollExp.push_back(Exp);
3478 }
3479
3480 LibUtilities::SessionReaderSharedPtr dummySession;
3481 Collections::CollectionOptimisation colOpt(dummySession, 3,
3482 Collections::eIterPerExp);
3483 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3484 Collections::Collection c(CollExp, impTypes);
3485 c.Initialise(Collections::eIProductWRTDerivBase);
3486
3487 const int nq = Exp->GetTotPoints();
3488 const int nm = Exp->GetNcoeffs();
3489 Array<OneD, NekDouble> phys1(nelmts * nq, 0.0);
3490 Array<OneD, NekDouble> phys2(nelmts * nq, 0.0);
3491 Array<OneD, NekDouble> phys3(nelmts * nq, 0.0);
3492 Array<OneD, NekDouble> coeffs1(nelmts * nm, 0.0);
3493 Array<OneD, NekDouble> coeffs2(nelmts * nm, 0.0);
3494 Array<OneD, NekDouble> tmp;
3495
3496 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3497
3498 Exp->GetCoords(xc, yc, zc);
3499
3500 for (int i = 0; i < nq; ++i)
3501 {
3502 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3503 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3504 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3505 }
3506
3507 for (int i = 1; i < nelmts; ++i)
3508 {
3509 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
3510 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
3511 Vmath::Vcopy(nq, phys3, 1, tmp = phys3 + i * nq, 1);
3512 }
3513
3514 // Standard routines
3515 for (int i = 0; i < nelmts; ++i)
3516 {
3517
3518 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
3519 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
3520 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3521 tmp = coeffs1 + i * nm, 1);
3522 Exp->IProductWRTDerivBase(2, phys3 + i * nq, tmp = coeffs2 + i * nm);
3523 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3524 tmp = coeffs1 + i * nm, 1);
3525 }
3526
3527 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3528 coeffs2);
3529
3530 double epsilon = 1.0e-6;
3531 for (int i = 0; i < coeffs1.size(); ++i)
3532 {
3533 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3534 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3535 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3536 }
3537}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), Vmath::Vadd(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [37/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_MatrixFree_UniformP_Deformed  )

Definition at line 3246 of file TestHexCollection.cpp.

3247{
3248 SpatialDomains::PointGeomSharedPtr v0(
3249 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
3250 SpatialDomains::PointGeomSharedPtr v1(
3251 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3252 SpatialDomains::PointGeomSharedPtr v2(
3253 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3254 SpatialDomains::PointGeomSharedPtr v3(
3255 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3256 SpatialDomains::PointGeomSharedPtr v4(
3257 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3258 SpatialDomains::PointGeomSharedPtr v5(
3259 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3260 SpatialDomains::PointGeomSharedPtr v6(
3261 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
3262 SpatialDomains::PointGeomSharedPtr v7(
3263 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3264
3265 SpatialDomains::HexGeomSharedPtr hexGeom =
3266 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3267
3268 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3269 Nektar::LibUtilities::eGaussLobattoLegendre;
3270 Nektar::LibUtilities::BasisType basisTypeDir1 =
3271 Nektar::LibUtilities::eModified_A;
3272 unsigned int numQuadPoints = 5;
3273 unsigned int numModes = 4;
3274 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3275 quadPointsTypeDir1);
3276 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
3277 quadPointsKeyDir1);
3278
3279 Nektar::LocalRegions::HexExpSharedPtr Exp =
3280 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3281 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3282
3283 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3284 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3285 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3286
3287 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3288 CollExp.push_back(Exp);
3289
3290 LibUtilities::SessionReaderSharedPtr dummySession;
3291 Collections::CollectionOptimisation colOpt(dummySession, 2,
3292 Collections::eMatrixFree);
3293 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3294 Collections::Collection c(CollExp, impTypes);
3295 c.Initialise(Collections::eIProductWRTDerivBase);
3296
3297 const int nq = Exp->GetTotPoints();
3298 const int nm = Exp->GetNcoeffs();
3299 Array<OneD, NekDouble> phys1(nq, 0.0);
3300 Array<OneD, NekDouble> phys2(nq, 0.0);
3301 Array<OneD, NekDouble> phys3(nq, 0.0);
3302 Array<OneD, NekDouble> coeffsRef(nm, 0.0);
3303 Array<OneD, NekDouble> coeffs(nm, 0.0);
3304
3305 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3306
3307 Exp->GetCoords(xc, yc, zc);
3308
3309 for (int i = 0; i < nq; ++i)
3310 {
3311 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3312 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3313 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3314 }
3315
3316 // Standard routines
3317 Exp->IProductWRTDerivBase(0, phys1, coeffsRef);
3318 Exp->IProductWRTDerivBase(1, phys2, coeffs);
3319 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3320 Exp->IProductWRTDerivBase(2, phys3, coeffs);
3321 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3322
3323 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3324 coeffs);
3325
3326 double epsilon = 1.0e-8;
3327 for (int i = 0; i < nm; ++i)
3328 {
3329 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
3330 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
3331 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
3332 }
3333}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [38/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_MatrixFree_UniformP_Deformed_OverInt  )

Definition at line 3335 of file TestHexCollection.cpp.

3337{
3338 SpatialDomains::PointGeomSharedPtr v0(
3339 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
3340 SpatialDomains::PointGeomSharedPtr v1(
3341 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3342 SpatialDomains::PointGeomSharedPtr v2(
3343 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3344 SpatialDomains::PointGeomSharedPtr v3(
3345 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3346 SpatialDomains::PointGeomSharedPtr v4(
3347 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3348 SpatialDomains::PointGeomSharedPtr v5(
3349 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3350 SpatialDomains::PointGeomSharedPtr v6(
3351 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
3352 SpatialDomains::PointGeomSharedPtr v7(
3353 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3354
3355 SpatialDomains::HexGeomSharedPtr hexGeom =
3356 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3357
3358 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3359 Nektar::LibUtilities::eGaussLobattoLegendre;
3360 Nektar::LibUtilities::BasisType basisTypeDir1 =
3361 Nektar::LibUtilities::eModified_A;
3362 unsigned int numQuadPoints = 8;
3363 unsigned int numModes = 4;
3364 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3365 quadPointsTypeDir1);
3366 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
3367 quadPointsKeyDir1);
3368
3369 Nektar::LocalRegions::HexExpSharedPtr Exp =
3370 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3371 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3372
3373 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3374 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3375 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3376
3377 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3378 CollExp.push_back(Exp);
3379
3380 LibUtilities::SessionReaderSharedPtr dummySession;
3381 Collections::CollectionOptimisation colOpt(dummySession, 2,
3382 Collections::eMatrixFree);
3383 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3384 Collections::Collection c(CollExp, impTypes);
3385 c.Initialise(Collections::eIProductWRTDerivBase);
3386
3387 const int nq = Exp->GetTotPoints();
3388 const int nm = Exp->GetNcoeffs();
3389 Array<OneD, NekDouble> phys1(nq, 0.0);
3390 Array<OneD, NekDouble> phys2(nq, 0.0);
3391 Array<OneD, NekDouble> phys3(nq, 0.0);
3392 Array<OneD, NekDouble> coeffsRef(nm, 0.0);
3393 Array<OneD, NekDouble> coeffs(nm, 0.0);
3394
3395 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3396
3397 Exp->GetCoords(xc, yc, zc);
3398
3399 for (int i = 0; i < nq; ++i)
3400 {
3401 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3402 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3403 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3404 }
3405
3406 // Standard routines
3407 Exp->IProductWRTDerivBase(0, phys1, coeffsRef);
3408 Exp->IProductWRTDerivBase(1, phys2, coeffs);
3409 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3410 Exp->IProductWRTDerivBase(2, phys3, coeffs);
3411 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3412
3413 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3414 coeffs);
3415
3416 double epsilon = 1.0e-8;
3417 for (int i = 0; i < nm; ++i)
3418 {
3419 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
3420 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
3421 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
3422 }
3423}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [39/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_MatrixFree_UniformP_Undeformed  )

Definition at line 3157 of file TestHexCollection.cpp.

3158{
3159 SpatialDomains::PointGeomSharedPtr v0(
3160 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
3161 SpatialDomains::PointGeomSharedPtr v1(
3162 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3163 SpatialDomains::PointGeomSharedPtr v2(
3164 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3165 SpatialDomains::PointGeomSharedPtr v3(
3166 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3167 SpatialDomains::PointGeomSharedPtr v4(
3168 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3169 SpatialDomains::PointGeomSharedPtr v5(
3170 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3171 SpatialDomains::PointGeomSharedPtr v6(
3172 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3173 SpatialDomains::PointGeomSharedPtr v7(
3174 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3175
3176 SpatialDomains::HexGeomSharedPtr hexGeom =
3177 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3178
3179 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3180 Nektar::LibUtilities::eGaussLobattoLegendre;
3181 Nektar::LibUtilities::BasisType basisTypeDir1 =
3182 Nektar::LibUtilities::eModified_A;
3183 unsigned int numQuadPoints = 5;
3184 unsigned int numModes = 4;
3185 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3186 quadPointsTypeDir1);
3187 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
3188 quadPointsKeyDir1);
3189
3190 Nektar::LocalRegions::HexExpSharedPtr Exp =
3191 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3192 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3193
3194 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3195 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3196 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3197
3198 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3199 CollExp.push_back(Exp);
3200
3201 LibUtilities::SessionReaderSharedPtr dummySession;
3202 Collections::CollectionOptimisation colOpt(dummySession, 2,
3203 Collections::eMatrixFree);
3204 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3205 Collections::Collection c(CollExp, impTypes);
3206 c.Initialise(Collections::eIProductWRTDerivBase);
3207
3208 const int nq = Exp->GetTotPoints();
3209 const int nm = Exp->GetNcoeffs();
3210 Array<OneD, NekDouble> phys1(nq, 0.0);
3211 Array<OneD, NekDouble> phys2(nq, 0.0);
3212 Array<OneD, NekDouble> phys3(nq, 0.0);
3213 Array<OneD, NekDouble> coeffsRef(nm, 0.0);
3214 Array<OneD, NekDouble> coeffs(nm, 0.0);
3215
3216 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3217
3218 Exp->GetCoords(xc, yc, zc);
3219
3220 for (int i = 0; i < nq; ++i)
3221 {
3222 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3223 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3224 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3225 }
3226
3227 // Standard routines
3228 Exp->IProductWRTDerivBase(0, phys1, coeffsRef);
3229 Exp->IProductWRTDerivBase(1, phys2, coeffs);
3230 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3231 Exp->IProductWRTDerivBase(2, phys3, coeffs);
3232 Vmath::Vadd(nm, coeffsRef, 1, coeffs, 1, coeffsRef, 1);
3233
3234 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3235 coeffs);
3236
3237 double epsilon = 1.0e-8;
3238 for (int i = 0; i < nm; ++i)
3239 {
3240 coeffsRef[i] = (std::abs(coeffsRef[i]) < 1e-14) ? 0.0 : coeffsRef[i];
3241 coeffs[i] = (std::abs(coeffs[i]) < 1e-14) ? 0.0 : coeffs[i];
3242 BOOST_CHECK_CLOSE(coeffsRef[i], coeffs[i], epsilon);
3243 }
3244}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [40/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_NoCollection_VariableP_MultiElmt  )

Definition at line 3741 of file TestHexCollection.cpp.

3743{
3744 SpatialDomains::PointGeomSharedPtr v0(
3745 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3746 SpatialDomains::PointGeomSharedPtr v1(
3747 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3748 SpatialDomains::PointGeomSharedPtr v2(
3749 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3750 SpatialDomains::PointGeomSharedPtr v3(
3751 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3752 SpatialDomains::PointGeomSharedPtr v4(
3753 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3754 SpatialDomains::PointGeomSharedPtr v5(
3755 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3756 SpatialDomains::PointGeomSharedPtr v6(
3757 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3758 SpatialDomains::PointGeomSharedPtr v7(
3759 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3760
3761 SpatialDomains::HexGeomSharedPtr hexGeom =
3762 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3763
3764 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3765 Nektar::LibUtilities::eGaussLobattoLegendre;
3766 Nektar::LibUtilities::BasisType basisTypeDir1 =
3767 Nektar::LibUtilities::eModified_A;
3768 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
3769 quadPointsTypeDir1);
3770 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
3771 quadPointsTypeDir1);
3772 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
3773 quadPointsTypeDir1);
3774 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3775 quadPointsKeyDir1);
3776 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
3777 quadPointsKeyDir2);
3778 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
3779 quadPointsKeyDir3);
3780
3781 Nektar::LocalRegions::HexExpSharedPtr Exp =
3782 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3783 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
3784
3785 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3786 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3787 basisKeyDir1, basisKeyDir2, basisKeyDir3);
3788
3789 int nelmts = 10;
3790
3791 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3792 for (int i = 0; i < nelmts; ++i)
3793 {
3794 CollExp.push_back(Exp);
3795 }
3796
3797 LibUtilities::SessionReaderSharedPtr dummySession;
3798 Collections::CollectionOptimisation colOpt(dummySession, 3,
3799 Collections::eNoCollection);
3800 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3801 Collections::Collection c(CollExp, impTypes);
3802 c.Initialise(Collections::eIProductWRTDerivBase);
3803
3804 const int nq = Exp->GetTotPoints();
3805 const int nm = Exp->GetNcoeffs();
3806 Array<OneD, NekDouble> phys1(nelmts * nq, 0.0);
3807 Array<OneD, NekDouble> phys2(nelmts * nq, 0.0);
3808 Array<OneD, NekDouble> phys3(nelmts * nq, 0.0);
3809 Array<OneD, NekDouble> coeffs1(nelmts * nm, 0.0);
3810 Array<OneD, NekDouble> coeffs2(nelmts * nm, 0.0);
3811 Array<OneD, NekDouble> tmp;
3812 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3813
3814 Exp->GetCoords(xc, yc, zc);
3815
3816 for (int i = 0; i < nq; ++i)
3817 {
3818 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3819 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3820 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3821 }
3822
3823 for (int i = 1; i < nelmts; ++i)
3824 {
3825 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
3826 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
3827 Vmath::Vcopy(nq, phys3, 1, tmp = phys3 + i * nq, 1);
3828 }
3829
3830 // Standard routines
3831 for (int i = 0; i < nelmts; ++i)
3832 {
3833
3834 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
3835 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
3836 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3837 tmp = coeffs1 + i * nm, 1);
3838 Exp->IProductWRTDerivBase(2, phys3 + i * nq, tmp = coeffs2 + i * nm);
3839 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3840 tmp = coeffs1 + i * nm, 1);
3841 }
3842
3843 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3844 coeffs2);
3845
3846 double epsilon = 1.0e-6;
3847 for (int i = 0; i < coeffs1.size(); ++i)
3848 {
3849 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3850 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3851 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3852 }
3853}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eNoCollection, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), Vmath::Vadd(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [41/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_StdMat_UniformP  )

Definition at line 3539 of file TestHexCollection.cpp.

3540{
3541 SpatialDomains::PointGeomSharedPtr v0(
3542 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3543 SpatialDomains::PointGeomSharedPtr v1(
3544 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3545 SpatialDomains::PointGeomSharedPtr v2(
3546 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3547 SpatialDomains::PointGeomSharedPtr v3(
3548 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3549 SpatialDomains::PointGeomSharedPtr v4(
3550 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3551 SpatialDomains::PointGeomSharedPtr v5(
3552 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3553 SpatialDomains::PointGeomSharedPtr v6(
3554 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3555 SpatialDomains::PointGeomSharedPtr v7(
3556 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3557
3558 SpatialDomains::HexGeomSharedPtr hexGeom =
3559 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3560
3561 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3562 Nektar::LibUtilities::eGaussLobattoLegendre;
3563 Nektar::LibUtilities::BasisType basisTypeDir1 =
3564 Nektar::LibUtilities::eModified_A;
3565 unsigned int numQuadPoints = 6;
3566 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3567 quadPointsTypeDir1);
3568 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3569 quadPointsKeyDir1);
3570
3571 Nektar::LocalRegions::HexExpSharedPtr Exp =
3572 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3573 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3574
3575 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3576 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3577 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3578
3579 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3580 CollExp.push_back(Exp);
3581
3582 LibUtilities::SessionReaderSharedPtr dummySession;
3583 Collections::CollectionOptimisation colOpt(dummySession, 3,
3584 Collections::eStdMat);
3585 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3586 Collections::Collection c(CollExp, impTypes);
3587 c.Initialise(Collections::eIProductWRTDerivBase);
3588
3589 const int nq = Exp->GetTotPoints();
3590 const int nm = Exp->GetNcoeffs();
3591 Array<OneD, NekDouble> phys1(nq, 0.0);
3592 Array<OneD, NekDouble> phys2(nq, 0.0);
3593 Array<OneD, NekDouble> phys3(nq, 0.0);
3594 Array<OneD, NekDouble> coeffs1(nm, 0.0);
3595 Array<OneD, NekDouble> coeffs2(nm, 0.0);
3596
3597 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3598
3599 Exp->GetCoords(xc, yc, zc);
3600
3601 for (int i = 0; i < nq; ++i)
3602 {
3603 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3604 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3605 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3606 }
3607
3608 // Standard routines
3609 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
3610 Exp->IProductWRTDerivBase(1, phys2, coeffs2);
3611 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3612 Exp->IProductWRTDerivBase(2, phys3, coeffs2);
3613 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3614
3615 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3616 coeffs2);
3617
3618 double epsilon = 1.0e-8;
3619 for (int i = 0; i < coeffs1.size(); ++i)
3620 {
3621 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3622 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3623 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3624 }
3625}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [42/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_StdMat_VariableP_MultiElmt  )

Definition at line 3627 of file TestHexCollection.cpp.

3628{
3629 SpatialDomains::PointGeomSharedPtr v0(
3630 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3631 SpatialDomains::PointGeomSharedPtr v1(
3632 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3633 SpatialDomains::PointGeomSharedPtr v2(
3634 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3635 SpatialDomains::PointGeomSharedPtr v3(
3636 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3637 SpatialDomains::PointGeomSharedPtr v4(
3638 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3639 SpatialDomains::PointGeomSharedPtr v5(
3640 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3641 SpatialDomains::PointGeomSharedPtr v6(
3642 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3643 SpatialDomains::PointGeomSharedPtr v7(
3644 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3645
3646 SpatialDomains::HexGeomSharedPtr hexGeom =
3647 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3648
3649 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3650 Nektar::LibUtilities::eGaussLobattoLegendre;
3651 Nektar::LibUtilities::BasisType basisTypeDir1 =
3652 Nektar::LibUtilities::eModified_A;
3653 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
3654 quadPointsTypeDir1);
3655 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
3656 quadPointsTypeDir1);
3657 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
3658 quadPointsTypeDir1);
3659 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3660 quadPointsKeyDir1);
3661 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
3662 quadPointsKeyDir2);
3663 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
3664 quadPointsKeyDir3);
3665
3666 Nektar::LocalRegions::HexExpSharedPtr Exp =
3667 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3668 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
3669
3670 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3671 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3672 basisKeyDir1, basisKeyDir2, basisKeyDir3);
3673
3674 int nelmts = 10;
3675
3676 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3677 for (int i = 0; i < nelmts; ++i)
3678 {
3679 CollExp.push_back(Exp);
3680 }
3681
3682 LibUtilities::SessionReaderSharedPtr dummySession;
3683 Collections::CollectionOptimisation colOpt(dummySession, 3,
3684 Collections::eStdMat);
3685 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3686 Collections::Collection c(CollExp, impTypes);
3687 c.Initialise(Collections::eIProductWRTDerivBase);
3688
3689 const int nq = Exp->GetTotPoints();
3690 const int nm = Exp->GetNcoeffs();
3691 Array<OneD, NekDouble> phys1(nelmts * nq, 0.0);
3692 Array<OneD, NekDouble> phys2(nelmts * nq, 0.0);
3693 Array<OneD, NekDouble> phys3(nelmts * nq, 0.0);
3694 Array<OneD, NekDouble> coeffs1(nelmts * nm, 0.0);
3695 Array<OneD, NekDouble> coeffs2(nelmts * nm, 0.0);
3696 Array<OneD, NekDouble> tmp;
3697
3698 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3699
3700 Exp->GetCoords(xc, yc, zc);
3701
3702 for (int i = 0; i < nq; ++i)
3703 {
3704 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3705 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3706 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3707 }
3708
3709 for (int i = 1; i < nelmts; ++i)
3710 {
3711 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
3712 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
3713 Vmath::Vcopy(nq, phys3, 1, tmp = phys3 + i * nq, 1);
3714 }
3715
3716 // Standard routines
3717 for (int i = 0; i < nelmts; ++i)
3718 {
3719
3720 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
3721 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
3722 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3723 tmp = coeffs1 + i * nm, 1);
3724 Exp->IProductWRTDerivBase(2, phys3 + i * nq, tmp = coeffs2 + i * nm);
3725 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
3726 tmp = coeffs1 + i * nm, 1);
3727 }
3728
3729 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3730 coeffs2);
3731
3732 double epsilon = 1.0e-8;
3733 for (int i = 0; i < coeffs1.size(); ++i)
3734 {
3735 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3736 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3737 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3738 }
3739}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), Vmath::Vadd(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [43/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_SumFac_UniformP  )

Definition at line 3855 of file TestHexCollection.cpp.

3856{
3857 SpatialDomains::PointGeomSharedPtr v0(
3858 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3859 SpatialDomains::PointGeomSharedPtr v1(
3860 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3861 SpatialDomains::PointGeomSharedPtr v2(
3862 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3863 SpatialDomains::PointGeomSharedPtr v3(
3864 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3865 SpatialDomains::PointGeomSharedPtr v4(
3866 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3867 SpatialDomains::PointGeomSharedPtr v5(
3868 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3869 SpatialDomains::PointGeomSharedPtr v6(
3870 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3871 SpatialDomains::PointGeomSharedPtr v7(
3872 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3873
3874 SpatialDomains::HexGeomSharedPtr hexGeom =
3875 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3876
3877 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3878 Nektar::LibUtilities::eGaussLobattoLegendre;
3879 Nektar::LibUtilities::BasisType basisTypeDir1 =
3880 Nektar::LibUtilities::eModified_A;
3881 unsigned int numQuadPoints = 6;
3882 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
3883 quadPointsTypeDir1);
3884 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3885 quadPointsKeyDir1);
3886
3887 Nektar::LocalRegions::HexExpSharedPtr Exp =
3888 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3889 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
3890
3891 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3892 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3893 basisKeyDir1, basisKeyDir1, basisKeyDir1);
3894
3895 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3896 CollExp.push_back(Exp);
3897
3898 LibUtilities::SessionReaderSharedPtr dummySession;
3899 Collections::CollectionOptimisation colOpt(dummySession, 3,
3900 Collections::eSumFac);
3901 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3902 Collections::Collection c(CollExp, impTypes);
3903 c.Initialise(Collections::eIProductWRTDerivBase);
3904
3905 const int nq = Exp->GetTotPoints();
3906 const int nm = Exp->GetNcoeffs();
3907 Array<OneD, NekDouble> phys1(nq, 0.0);
3908 Array<OneD, NekDouble> phys2(nq, 0.0);
3909 Array<OneD, NekDouble> phys3(nq, 0.0);
3910 Array<OneD, NekDouble> coeffs1(nm, 0.0);
3911 Array<OneD, NekDouble> coeffs2(nm, 0.0);
3912
3913 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3914
3915 Exp->GetCoords(xc, yc, zc);
3916
3917 for (int i = 0; i < nq; ++i)
3918 {
3919 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3920 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
3921 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
3922 }
3923
3924 // Standard routines
3925 Exp->IProductWRTDerivBase(0, phys1, coeffs1);
3926 Exp->IProductWRTDerivBase(1, phys2, coeffs2);
3927 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3928 Exp->IProductWRTDerivBase(2, phys3, coeffs2);
3929 Vmath::Vadd(nm, coeffs1, 1, coeffs2, 1, coeffs1, 1);
3930
3931 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
3932 coeffs2);
3933
3934 double epsilon = 1.0e-8;
3935 for (int i = 0; i < coeffs1.size(); ++i)
3936 {
3937 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
3938 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
3939 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
3940 }
3941}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vadd().

◆ BOOST_AUTO_TEST_CASE() [44/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexIProductWRTDerivBase_SumFac_VariableP_MultiElmt  )

Definition at line 3943 of file TestHexCollection.cpp.

3944{
3945 SpatialDomains::PointGeomSharedPtr v0(
3946 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
3947 SpatialDomains::PointGeomSharedPtr v1(
3948 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
3949 SpatialDomains::PointGeomSharedPtr v2(
3950 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
3951 SpatialDomains::PointGeomSharedPtr v3(
3952 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
3953 SpatialDomains::PointGeomSharedPtr v4(
3954 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
3955 SpatialDomains::PointGeomSharedPtr v5(
3956 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
3957 SpatialDomains::PointGeomSharedPtr v6(
3958 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
3959 SpatialDomains::PointGeomSharedPtr v7(
3960 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
3961
3962 SpatialDomains::HexGeomSharedPtr hexGeom =
3963 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
3964
3965 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
3966 Nektar::LibUtilities::eGaussLobattoLegendre;
3967 Nektar::LibUtilities::BasisType basisTypeDir1 =
3968 Nektar::LibUtilities::eModified_A;
3969 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
3970 quadPointsTypeDir1);
3971 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
3972 quadPointsTypeDir1);
3973 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
3974 quadPointsTypeDir1);
3975 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3976 quadPointsKeyDir1);
3977 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
3978 quadPointsKeyDir2);
3979 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
3980 quadPointsKeyDir3);
3981
3982 Nektar::LocalRegions::HexExpSharedPtr Exp =
3983 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3984 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
3985
3986 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3987 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3988 basisKeyDir1, basisKeyDir2, basisKeyDir3);
3989
3990 int nelmts = 10;
3991
3992 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3993 for (int i = 0; i < nelmts; ++i)
3994 {
3995 CollExp.push_back(Exp);
3996 }
3997
3998 LibUtilities::SessionReaderSharedPtr dummySession;
3999 Collections::CollectionOptimisation colOpt(dummySession, 3,
4000 Collections::eSumFac);
4001 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
4002 Collections::Collection c(CollExp, impTypes);
4003 c.Initialise(Collections::eIProductWRTDerivBase);
4004
4005 const int nq = Exp->GetTotPoints();
4006 const int nm = Exp->GetNcoeffs();
4007 Array<OneD, NekDouble> phys1(nelmts * nq, 0.0);
4008 Array<OneD, NekDouble> phys2(nelmts * nq, 0.0);
4009 Array<OneD, NekDouble> phys3(nelmts * nq, 0.0);
4010 Array<OneD, NekDouble> coeffs1(nelmts * nm, 0.0);
4011 Array<OneD, NekDouble> coeffs2(nelmts * nm, 0.0);
4012 Array<OneD, NekDouble> tmp;
4013
4014 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
4015
4016 Exp->GetCoords(xc, yc, zc);
4017
4018 for (int i = 0; i < nq; ++i)
4019 {
4020 phys1[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
4021 phys2[i] = cos(xc[i]) * sin(yc[i]) * cos(zc[i]);
4022 phys2[i] = cos(xc[i]) * sin(yc[i]) * sin(zc[i]);
4023 }
4024
4025 for (int i = 1; i < nelmts; ++i)
4026 {
4027 Vmath::Vcopy(nq, phys1, 1, tmp = phys1 + i * nq, 1);
4028 Vmath::Vcopy(nq, phys2, 1, tmp = phys2 + i * nq, 1);
4029 Vmath::Vcopy(nq, phys3, 1, tmp = phys3 + i * nq, 1);
4030 }
4031
4032 // Standard routines
4033 for (int i = 0; i < nelmts; ++i)
4034 {
4035 Exp->IProductWRTDerivBase(0, phys1 + i * nq, tmp = coeffs1 + i * nm);
4036 Exp->IProductWRTDerivBase(1, phys2 + i * nq, tmp = coeffs2 + i * nm);
4037 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
4038 tmp = coeffs1 + i * nm, 1);
4039 Exp->IProductWRTDerivBase(2, phys3 + i * nq, tmp = coeffs2 + i * nm);
4040 Vmath::Vadd(nm, coeffs1 + i * nm, 1, coeffs2 + i * nm, 1,
4041 tmp = coeffs1 + i * nm, 1);
4042 }
4043
4044 c.ApplyOperator(Collections::eIProductWRTDerivBase, phys1, phys2, phys3,
4045 coeffs2);
4046
4047 double epsilon = 1.0e-8;
4048 for (int i = 0; i < coeffs1.size(); ++i)
4049 {
4050 coeffs1[i] = (std::abs(coeffs1[i]) < 1e-14) ? 0.0 : coeffs1[i];
4051 coeffs2[i] = (std::abs(coeffs2[i]) < 1e-14) ? 0.0 : coeffs2[i];
4052 BOOST_CHECK_CLOSE(coeffs1[i], coeffs2[i], epsilon);
4053 }
4054}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIProductWRTDerivBase, Nektar::LibUtilities::eModified_A, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), Vmath::Vadd(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [45/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_IterPerExp_UniformP  )

Definition at line 2316 of file TestHexCollection.cpp.

2317{
2318 SpatialDomains::PointGeomSharedPtr v0(
2319 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2320 SpatialDomains::PointGeomSharedPtr v1(
2321 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2322 SpatialDomains::PointGeomSharedPtr v2(
2323 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2324 SpatialDomains::PointGeomSharedPtr v3(
2325 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2326 SpatialDomains::PointGeomSharedPtr v4(
2327 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2328 SpatialDomains::PointGeomSharedPtr v5(
2329 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2330 SpatialDomains::PointGeomSharedPtr v6(
2331 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2332 SpatialDomains::PointGeomSharedPtr v7(
2333 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2334
2335 SpatialDomains::HexGeomSharedPtr hexGeom =
2336 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2337
2338 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2339 Nektar::LibUtilities::eGaussLobattoLegendre;
2340 Nektar::LibUtilities::BasisType basisTypeDir1 =
2341 Nektar::LibUtilities::eModified_A;
2342 unsigned int numQuadPoints = 6;
2343 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
2344 quadPointsTypeDir1);
2345 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2346 quadPointsKeyDir1);
2347
2348 Nektar::LocalRegions::HexExpSharedPtr Exp =
2349 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2350 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
2351
2352 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2353 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2354 basisKeyDir1, basisKeyDir1, basisKeyDir1);
2355
2356 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2357 CollExp.push_back(Exp);
2358
2359 LibUtilities::SessionReaderSharedPtr dummySession;
2360 Collections::CollectionOptimisation colOpt(dummySession, 3,
2361 Collections::eIterPerExp);
2362 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2363 Collections::Collection c(CollExp, impTypes);
2364 c.Initialise(Collections::ePhysDeriv);
2365
2366 const int nq = Exp->GetTotPoints();
2367 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2368 Array<OneD, NekDouble> phys(nq), tmp, tmp1, tmp2;
2369 Array<OneD, NekDouble> diff1(3 * nq);
2370 Array<OneD, NekDouble> diff2(3 * nq);
2371
2372 Exp->GetCoords(xc, yc, zc);
2373
2374 for (int i = 0; i < nq; ++i)
2375 {
2376 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2377 }
2378
2379 Exp->PhysDeriv(phys, diff1, tmp = diff1 + nq, tmp1 = diff1 + 2 * nq);
2380 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2, tmp = diff2 + nq,
2381 tmp2 = diff2 + 2 * nq);
2382
2383 double epsilon = 1.0e-8;
2384 for (int i = 0; i < diff1.size(); ++i)
2385 {
2386 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2387 }
2388}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [46/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_IterPerExp_VariableP_MultiElmt  )

Definition at line 2544 of file TestHexCollection.cpp.

2545{
2546 SpatialDomains::PointGeomSharedPtr v0(
2547 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2548 SpatialDomains::PointGeomSharedPtr v1(
2549 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2550 SpatialDomains::PointGeomSharedPtr v2(
2551 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2552 SpatialDomains::PointGeomSharedPtr v3(
2553 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2554 SpatialDomains::PointGeomSharedPtr v4(
2555 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2556 SpatialDomains::PointGeomSharedPtr v5(
2557 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2558 SpatialDomains::PointGeomSharedPtr v6(
2559 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2560 SpatialDomains::PointGeomSharedPtr v7(
2561 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2562
2563 SpatialDomains::HexGeomSharedPtr hexGeom =
2564 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2565
2566 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2567 Nektar::LibUtilities::eGaussLobattoLegendre;
2568 Nektar::LibUtilities::BasisType basisTypeDir1 =
2569 Nektar::LibUtilities::eModified_A;
2570 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
2571 quadPointsTypeDir1);
2572 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
2573 quadPointsTypeDir1);
2574 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
2575 quadPointsTypeDir1);
2576 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2577 quadPointsKeyDir1);
2578 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2579 quadPointsKeyDir2);
2580 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2581 quadPointsKeyDir3);
2582
2583 Nektar::LocalRegions::HexExpSharedPtr Exp =
2584 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2585 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2586
2587 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2588 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2589 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2590
2591 int nelmts = 10;
2592
2593 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2594 for (int i = 0; i < nelmts; ++i)
2595 {
2596 CollExp.push_back(Exp);
2597 }
2598
2599 LibUtilities::SessionReaderSharedPtr dummySession;
2600 Collections::CollectionOptimisation colOpt(dummySession, 3,
2601 Collections::eIterPerExp);
2602 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2603 Collections::Collection c(CollExp, impTypes);
2604 c.Initialise(Collections::ePhysDeriv);
2605
2606 const int nq = Exp->GetTotPoints();
2607 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2608 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1, tmp2;
2609 Array<OneD, NekDouble> diff1(3 * nelmts * nq);
2610 Array<OneD, NekDouble> diff2(3 * nelmts * nq);
2611
2612 Exp->GetCoords(xc, yc, zc);
2613
2614 for (int i = 0; i < nq; ++i)
2615 {
2616 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2617 }
2618 Exp->PhysDeriv(phys, tmp = diff1, tmp1 = diff1 + (nelmts)*nq,
2619 tmp2 = diff1 + (2 * nelmts) * nq);
2620 for (int i = 1; i < nelmts; ++i)
2621 {
2622 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
2623 Exp->PhysDeriv(phys, tmp = diff1 + i * nq,
2624 tmp1 = diff1 + (nelmts + i) * nq,
2625 tmp2 = diff1 + (2 * nelmts + i) * nq);
2626 }
2627
2628 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
2629 tmp = diff2 + nelmts * nq, tmp2 = diff2 + 2 * nelmts * nq);
2630
2631 double epsilon = 1.0e-8;
2632 for (int i = 0; i < diff1.size(); ++i)
2633 {
2634 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2635 }
2636}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eIterPerExp, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [47/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_MatrixFree_UniformP_Deformed  )

Definition at line 2467 of file TestHexCollection.cpp.

2468{
2469 SpatialDomains::PointGeomSharedPtr v0(
2470 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
2471 SpatialDomains::PointGeomSharedPtr v1(
2472 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2473 SpatialDomains::PointGeomSharedPtr v2(
2474 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2475 SpatialDomains::PointGeomSharedPtr v3(
2476 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2477 SpatialDomains::PointGeomSharedPtr v4(
2478 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2479 SpatialDomains::PointGeomSharedPtr v5(
2480 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2481 SpatialDomains::PointGeomSharedPtr v6(
2482 new SpatialDomains::PointGeom(3u, 6u, 2.0, 3.0, 4.0));
2483 SpatialDomains::PointGeomSharedPtr v7(
2484 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2485
2486 SpatialDomains::HexGeomSharedPtr hexGeom =
2487 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2488
2489 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2490 Nektar::LibUtilities::eGaussLobattoLegendre;
2491 Nektar::LibUtilities::BasisType basisTypeDir1 =
2492 Nektar::LibUtilities::eModified_A;
2493 unsigned int numQuadPoints = 5;
2494 unsigned int numModes = 2;
2495 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
2496 quadPointsTypeDir1);
2497 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
2498 quadPointsKeyDir1);
2499
2500 Nektar::LocalRegions::HexExpSharedPtr Exp =
2501 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2502 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
2503
2504 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2505 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2506 basisKeyDir1, basisKeyDir1, basisKeyDir1);
2507
2508 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2509 CollExp.push_back(Exp);
2510
2511 LibUtilities::SessionReaderSharedPtr dummySession;
2512 Collections::CollectionOptimisation colOpt(dummySession, 2,
2513 Collections::eMatrixFree);
2514 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2515 Collections::Collection c(CollExp, impTypes);
2516 c.Initialise(Collections::ePhysDeriv);
2517
2518 const int nq = Exp->GetTotPoints();
2519 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2520 Array<OneD, NekDouble> phys(nq), tmp, tmp1, tmp2;
2521 Array<OneD, NekDouble> diffRef(3 * nq);
2522 Array<OneD, NekDouble> diff(3 * nq);
2523
2524 Exp->GetCoords(xc, yc, zc);
2525
2526 for (int i = 0; i < nq; ++i)
2527 {
2528 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2529 }
2530
2531 Exp->PhysDeriv(phys, diffRef, tmp = diffRef + nq, tmp1 = diffRef + 2 * nq);
2532 c.ApplyOperator(Collections::ePhysDeriv, phys, diff, tmp = diff + nq,
2533 tmp2 = diff + 2 * nq);
2534
2535 double epsilon = 1.0e-8;
2536 for (int i = 0; i < diffRef.size(); ++i)
2537 {
2538 diffRef[i] = (std::abs(diffRef[i]) < 1e-14) ? 0.0 : diffRef[i];
2539 diff[i] = (std::abs(diff[i]) < 1e-14) ? 0.0 : diff[i];
2540 BOOST_CHECK_CLOSE(diffRef[i], diff[i], epsilon);
2541 }
2542}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [48/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_MatrixFree_UniformP_Undeformed  )

Definition at line 2390 of file TestHexCollection.cpp.

2391{
2392 SpatialDomains::PointGeomSharedPtr v0(
2393 new SpatialDomains::PointGeom(3u, 0u, -1.0, -1.0, -1.0));
2394 SpatialDomains::PointGeomSharedPtr v1(
2395 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2396 SpatialDomains::PointGeomSharedPtr v2(
2397 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2398 SpatialDomains::PointGeomSharedPtr v3(
2399 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2400 SpatialDomains::PointGeomSharedPtr v4(
2401 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2402 SpatialDomains::PointGeomSharedPtr v5(
2403 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2404 SpatialDomains::PointGeomSharedPtr v6(
2405 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2406 SpatialDomains::PointGeomSharedPtr v7(
2407 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2408
2409 SpatialDomains::HexGeomSharedPtr hexGeom =
2410 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2411
2412 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2413 Nektar::LibUtilities::eGaussLobattoLegendre;
2414 Nektar::LibUtilities::BasisType basisTypeDir1 =
2415 Nektar::LibUtilities::eModified_A;
2416 unsigned int numQuadPoints = 6;
2417 unsigned int numModes = 2;
2418 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
2419 quadPointsTypeDir1);
2420 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, numModes,
2421 quadPointsKeyDir1);
2422
2423 Nektar::LocalRegions::HexExpSharedPtr Exp =
2424 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2425 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
2426
2427 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2428 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2429 basisKeyDir1, basisKeyDir1, basisKeyDir1);
2430
2431 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2432 CollExp.push_back(Exp);
2433
2434 LibUtilities::SessionReaderSharedPtr dummySession;
2435 Collections::CollectionOptimisation colOpt(dummySession, 2,
2436 Collections::eMatrixFree);
2437 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2438 Collections::Collection c(CollExp, impTypes);
2439 c.Initialise(Collections::ePhysDeriv);
2440
2441 const int nq = Exp->GetTotPoints();
2442 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2443 Array<OneD, NekDouble> phys(nq), tmp, tmp1, tmp2;
2444 Array<OneD, NekDouble> diffRef(3 * nq);
2445 Array<OneD, NekDouble> diff(3 * nq);
2446
2447 Exp->GetCoords(xc, yc, zc);
2448
2449 for (int i = 0; i < nq; ++i)
2450 {
2451 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2452 }
2453
2454 Exp->PhysDeriv(phys, diffRef, tmp = diffRef + nq, tmp1 = diffRef + 2 * nq);
2455 c.ApplyOperator(Collections::ePhysDeriv, phys, diff, tmp = diff + nq,
2456 tmp2 = diff + 2 * nq);
2457
2458 double epsilon = 1.0e-8;
2459 for (int i = 0; i < diffRef.size(); ++i)
2460 {
2461 diffRef[i] = (std::abs(diffRef[i]) < 1e-14) ? 0.0 : diffRef[i];
2462 diff[i] = (std::abs(diff[i]) < 1e-14) ? 0.0 : diff[i];
2463 BOOST_CHECK_CLOSE(diffRef[i], diff[i], epsilon);
2464 }
2465}

References tinysimd::abs(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::Collections::eMatrixFree, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [49/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_NoCollection_VariableP_MultiElmt  )

Definition at line 2638 of file TestHexCollection.cpp.

2639{
2640 SpatialDomains::PointGeomSharedPtr v0(
2641 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2642 SpatialDomains::PointGeomSharedPtr v1(
2643 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2644 SpatialDomains::PointGeomSharedPtr v2(
2645 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2646 SpatialDomains::PointGeomSharedPtr v3(
2647 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2648 SpatialDomains::PointGeomSharedPtr v4(
2649 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2650 SpatialDomains::PointGeomSharedPtr v5(
2651 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2652 SpatialDomains::PointGeomSharedPtr v6(
2653 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2654 SpatialDomains::PointGeomSharedPtr v7(
2655 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2656
2657 SpatialDomains::HexGeomSharedPtr hexGeom =
2658 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2659
2660 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2661 Nektar::LibUtilities::eGaussLobattoLegendre;
2662 Nektar::LibUtilities::BasisType basisTypeDir1 =
2663 Nektar::LibUtilities::eModified_A;
2664 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
2665 quadPointsTypeDir1);
2666 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
2667 quadPointsTypeDir1);
2668 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
2669 quadPointsTypeDir1);
2670 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2671 quadPointsKeyDir1);
2672 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2673 quadPointsKeyDir2);
2674 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2675 quadPointsKeyDir3);
2676
2677 Nektar::LocalRegions::HexExpSharedPtr Exp =
2678 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2679 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2680
2681 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2682 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2683 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2684
2685 int nelmts = 10;
2686
2687 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2688 for (int i = 0; i < nelmts; ++i)
2689 {
2690 CollExp.push_back(Exp);
2691 }
2692
2693 LibUtilities::SessionReaderSharedPtr dummySession;
2694 Collections::CollectionOptimisation colOpt(dummySession, 3,
2695 Collections::eNoCollection);
2696 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2697 Collections::Collection c(CollExp, impTypes);
2698 c.Initialise(Collections::ePhysDeriv);
2699
2700 const int nq = Exp->GetTotPoints();
2701 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2702 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1, tmp2;
2703 Array<OneD, NekDouble> diff1(3 * nelmts * nq);
2704 Array<OneD, NekDouble> diff2(3 * nelmts * nq);
2705
2706 Exp->GetCoords(xc, yc, zc);
2707
2708 for (int i = 0; i < nq; ++i)
2709 {
2710 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2711 }
2712 Exp->PhysDeriv(phys, tmp = diff1, tmp1 = diff1 + (nelmts)*nq,
2713 tmp2 = diff1 + (2 * nelmts) * nq);
2714
2715 for (int i = 1; i < nelmts; ++i)
2716 {
2717 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
2718 Exp->PhysDeriv(phys, tmp = diff1 + i * nq,
2719 tmp1 = diff1 + (nelmts + i) * nq,
2720 tmp2 = diff1 + (2 * nelmts + i) * nq);
2721 }
2722
2723 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
2724 tmp = diff2 + nelmts * nq, tmp2 = diff2 + 2 * nelmts * nq);
2725
2726 double epsilon = 1.0e-8;
2727 for (int i = 0; i < diff1.size(); ++i)
2728 {
2729 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2730 }
2731}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::eNoCollection, Nektar::Collections::ePhysDeriv, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [50/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_StdMat_UniformP  )

Definition at line 2733 of file TestHexCollection.cpp.

2734{
2735 SpatialDomains::PointGeomSharedPtr v0(
2736 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2737 SpatialDomains::PointGeomSharedPtr v1(
2738 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2739 SpatialDomains::PointGeomSharedPtr v2(
2740 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2741 SpatialDomains::PointGeomSharedPtr v3(
2742 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2743 SpatialDomains::PointGeomSharedPtr v4(
2744 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2745 SpatialDomains::PointGeomSharedPtr v5(
2746 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2747 SpatialDomains::PointGeomSharedPtr v6(
2748 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2749 SpatialDomains::PointGeomSharedPtr v7(
2750 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2751
2752 SpatialDomains::HexGeomSharedPtr hexGeom =
2753 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2754
2755 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2756 Nektar::LibUtilities::eGaussLobattoLegendre;
2757 Nektar::LibUtilities::BasisType basisTypeDir1 =
2758 Nektar::LibUtilities::eModified_A;
2759 unsigned int numQuadPoints = 4;
2760 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
2761 quadPointsTypeDir1);
2762 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 3,
2763 quadPointsKeyDir1);
2764
2765 Nektar::LocalRegions::HexExpSharedPtr Exp =
2766 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2767 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
2768
2769 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2770 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2771 basisKeyDir1, basisKeyDir1, basisKeyDir1);
2772
2773 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2774 CollExp.push_back(Exp);
2775
2776 LibUtilities::SessionReaderSharedPtr dummySession;
2777 Collections::CollectionOptimisation colOpt(dummySession, 3,
2778 Collections::eStdMat);
2779 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2780 Collections::Collection c(CollExp, impTypes);
2781 c.Initialise(Collections::ePhysDeriv);
2782
2783 const int nq = Exp->GetTotPoints();
2784 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2785 Array<OneD, NekDouble> phys(nq), tmp, tmp1, tmp2;
2786 Array<OneD, NekDouble> diff1(3 * nq);
2787 Array<OneD, NekDouble> diff2(3 * nq);
2788
2789 Exp->GetCoords(xc, yc, zc);
2790
2791 for (int i = 0; i < nq; ++i)
2792 {
2793 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2794 }
2795
2796 Exp->PhysDeriv(phys, diff1, tmp = diff1 + nq, tmp1 = diff1 + 2 * nq);
2797 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2, tmp = diff2 + nq,
2798 tmp2 = diff2 + 2 * nq);
2799
2800 double epsilon = 1.0e-8;
2801 for (int i = 0; i < diff1.size(); ++i)
2802 {
2803 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2804 }
2805}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [51/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_StdMat_VariableP_MultiElmt  )

Definition at line 2807 of file TestHexCollection.cpp.

2808{
2809 SpatialDomains::PointGeomSharedPtr v0(
2810 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2811 SpatialDomains::PointGeomSharedPtr v1(
2812 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2813 SpatialDomains::PointGeomSharedPtr v2(
2814 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2815 SpatialDomains::PointGeomSharedPtr v3(
2816 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2817 SpatialDomains::PointGeomSharedPtr v4(
2818 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2819 SpatialDomains::PointGeomSharedPtr v5(
2820 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2821 SpatialDomains::PointGeomSharedPtr v6(
2822 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2823 SpatialDomains::PointGeomSharedPtr v7(
2824 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2825
2826 SpatialDomains::HexGeomSharedPtr hexGeom =
2827 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2828
2829 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2830 Nektar::LibUtilities::eGaussLobattoLegendre;
2831 Nektar::LibUtilities::BasisType basisTypeDir1 =
2832 Nektar::LibUtilities::eModified_A;
2833 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
2834 quadPointsTypeDir1);
2835 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
2836 quadPointsTypeDir1);
2837 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
2838 quadPointsTypeDir1);
2839 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2840 quadPointsKeyDir1);
2841 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
2842 quadPointsKeyDir2);
2843 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
2844 quadPointsKeyDir3);
2845
2846 Nektar::LocalRegions::HexExpSharedPtr Exp =
2847 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2848 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
2849
2850 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2851 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2852 basisKeyDir1, basisKeyDir2, basisKeyDir3);
2853
2854 int nelmts = 10;
2855
2856 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2857 for (int i = 0; i < nelmts; ++i)
2858 {
2859 CollExp.push_back(Exp);
2860 }
2861
2862 LibUtilities::SessionReaderSharedPtr dummySession;
2863 Collections::CollectionOptimisation colOpt(dummySession, 3,
2864 Collections::eStdMat);
2865 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2866 Collections::Collection c(CollExp, impTypes);
2867 c.Initialise(Collections::ePhysDeriv);
2868
2869 const int nq = Exp->GetTotPoints();
2870 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2871 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1, tmp2;
2872 Array<OneD, NekDouble> diff1(3 * nelmts * nq);
2873 Array<OneD, NekDouble> diff2(3 * nelmts * nq);
2874
2875 Exp->GetCoords(xc, yc, zc);
2876
2877 for (int i = 0; i < nq; ++i)
2878 {
2879 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2880 }
2881 Exp->PhysDeriv(phys, tmp = diff1, tmp1 = diff1 + (nelmts)*nq,
2882 tmp2 = diff1 + (2 * nelmts) * nq);
2883 for (int i = 1; i < nelmts; ++i)
2884 {
2885 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
2886 Exp->PhysDeriv(phys, tmp = diff1 + i * nq,
2887 tmp1 = diff1 + (nelmts + i) * nq,
2888 tmp2 = diff1 + (2 * nelmts + i) * nq);
2889 }
2890
2891 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
2892 tmp = diff2 + nelmts * nq, tmp2 = diff2 + 2 * nelmts * nq);
2893
2894 double epsilon = 1.0e-8;
2895 for (int i = 0; i < diff1.size(); ++i)
2896 {
2897 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2898 }
2899}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::eStdMat, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ BOOST_AUTO_TEST_CASE() [52/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_SumFac_UniformP  )

Definition at line 2901 of file TestHexCollection.cpp.

2902{
2903 SpatialDomains::PointGeomSharedPtr v0(
2904 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2905 SpatialDomains::PointGeomSharedPtr v1(
2906 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2907 SpatialDomains::PointGeomSharedPtr v2(
2908 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2909 SpatialDomains::PointGeomSharedPtr v3(
2910 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2911 SpatialDomains::PointGeomSharedPtr v4(
2912 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2913 SpatialDomains::PointGeomSharedPtr v5(
2914 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2915 SpatialDomains::PointGeomSharedPtr v6(
2916 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2917 SpatialDomains::PointGeomSharedPtr v7(
2918 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2919
2920 SpatialDomains::HexGeomSharedPtr hexGeom =
2921 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2922
2923 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2924 Nektar::LibUtilities::eGaussLobattoLegendre;
2925 Nektar::LibUtilities::BasisType basisTypeDir1 =
2926 Nektar::LibUtilities::eModified_A;
2927 unsigned int numQuadPoints = 6;
2928 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(numQuadPoints,
2929 quadPointsTypeDir1);
2930 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
2931 quadPointsKeyDir1);
2932
2933 Nektar::LocalRegions::HexExpSharedPtr Exp =
2934 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
2935 basisKeyDir1, basisKeyDir1, basisKeyDir1, hexGeom);
2936
2937 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
2938 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
2939 basisKeyDir1, basisKeyDir1, basisKeyDir1);
2940
2941 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
2942 CollExp.push_back(Exp);
2943
2944 LibUtilities::SessionReaderSharedPtr dummySession;
2945 Collections::CollectionOptimisation colOpt(dummySession, 3,
2946 Collections::eSumFac);
2947 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
2948 Collections::Collection c(CollExp, impTypes);
2949 c.Initialise(Collections::ePhysDeriv);
2950
2951 const int nq = Exp->GetTotPoints();
2952 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
2953 Array<OneD, NekDouble> phys(nq), tmp, tmp1, tmp2;
2954 Array<OneD, NekDouble> diff1(3 * nq);
2955 Array<OneD, NekDouble> diff2(3 * nq);
2956
2957 Exp->GetCoords(xc, yc, zc);
2958
2959 for (int i = 0; i < nq; ++i)
2960 {
2961 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
2962 }
2963
2964 Exp->PhysDeriv(phys, diff1, tmp = diff1 + nq, tmp1 = diff1 + 2 * nq);
2965 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2, tmp = diff2 + nq,
2966 tmp2 = diff2 + 2 * nq);
2967
2968 double epsilon = 1.0e-8;
2969 for (int i = 0; i < diff1.size(); ++i)
2970 {
2971 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
2972 }
2973}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), and Nektar::Collections::Collection::Initialise().

◆ BOOST_AUTO_TEST_CASE() [53/53]

Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE ( TestHexPhysDeriv_SumFac_VariableP_MultiElmt  )

Definition at line 2975 of file TestHexCollection.cpp.

2976{
2977 SpatialDomains::PointGeomSharedPtr v0(
2978 new SpatialDomains::PointGeom(3u, 0u, -1.5, -1.5, -1.5));
2979 SpatialDomains::PointGeomSharedPtr v1(
2980 new SpatialDomains::PointGeom(3u, 1u, 1.0, -1.0, -1.0));
2981 SpatialDomains::PointGeomSharedPtr v2(
2982 new SpatialDomains::PointGeom(3u, 2u, 1.0, 1.0, -1.0));
2983 SpatialDomains::PointGeomSharedPtr v3(
2984 new SpatialDomains::PointGeom(3u, 3u, -1.0, 1.0, -1.0));
2985 SpatialDomains::PointGeomSharedPtr v4(
2986 new SpatialDomains::PointGeom(3u, 4u, -1.0, -1.0, 1.0));
2987 SpatialDomains::PointGeomSharedPtr v5(
2988 new SpatialDomains::PointGeom(3u, 5u, 1.0, -1.0, 1.0));
2989 SpatialDomains::PointGeomSharedPtr v6(
2990 new SpatialDomains::PointGeom(3u, 6u, 1.0, 1.0, 1.0));
2991 SpatialDomains::PointGeomSharedPtr v7(
2992 new SpatialDomains::PointGeom(3u, 7u, -1.0, 1.0, 1.0));
2993
2994 SpatialDomains::HexGeomSharedPtr hexGeom =
2995 CreateHex(v0, v1, v2, v3, v4, v5, v6, v7);
2996
2997 Nektar::LibUtilities::PointsType quadPointsTypeDir1 =
2998 Nektar::LibUtilities::eGaussLobattoLegendre;
2999 Nektar::LibUtilities::BasisType basisTypeDir1 =
3000 Nektar::LibUtilities::eModified_A;
3001 const Nektar::LibUtilities::PointsKey quadPointsKeyDir1(5,
3002 quadPointsTypeDir1);
3003 const Nektar::LibUtilities::PointsKey quadPointsKeyDir2(6,
3004 quadPointsTypeDir1);
3005 const Nektar::LibUtilities::PointsKey quadPointsKeyDir3(8,
3006 quadPointsTypeDir1);
3007 const Nektar::LibUtilities::BasisKey basisKeyDir1(basisTypeDir1, 4,
3008 quadPointsKeyDir1);
3009 const Nektar::LibUtilities::BasisKey basisKeyDir2(basisTypeDir1, 6,
3010 quadPointsKeyDir2);
3011 const Nektar::LibUtilities::BasisKey basisKeyDir3(basisTypeDir1, 8,
3012 quadPointsKeyDir3);
3013
3014 Nektar::LocalRegions::HexExpSharedPtr Exp =
3015 MemoryManager<Nektar::LocalRegions::HexExp>::AllocateSharedPtr(
3016 basisKeyDir1, basisKeyDir2, basisKeyDir3, hexGeom);
3017
3018 Nektar::StdRegions::StdHexExpSharedPtr stdExp =
3019 MemoryManager<Nektar::StdRegions::StdHexExp>::AllocateSharedPtr(
3020 basisKeyDir1, basisKeyDir2, basisKeyDir3);
3021
3022 int nelmts = 10;
3023
3024 std::vector<StdRegions::StdExpansionSharedPtr> CollExp;
3025 for (int i = 0; i < nelmts; ++i)
3026 {
3027 CollExp.push_back(Exp);
3028 }
3029
3030 LibUtilities::SessionReaderSharedPtr dummySession;
3031 Collections::CollectionOptimisation colOpt(dummySession, 3,
3032 Collections::eSumFac);
3033 Collections::OperatorImpMap impTypes = colOpt.GetOperatorImpMap(stdExp);
3034 Collections::Collection c(CollExp, impTypes);
3035 c.Initialise(Collections::ePhysDeriv);
3036
3037 const int nq = Exp->GetTotPoints();
3038 Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq);
3039 Array<OneD, NekDouble> phys(nelmts * nq), tmp, tmp1, tmp2;
3040 Array<OneD, NekDouble> diff1(3 * nelmts * nq);
3041 Array<OneD, NekDouble> diff2(3 * nelmts * nq);
3042
3043 Exp->GetCoords(xc, yc, zc);
3044
3045 for (int i = 0; i < nq; ++i)
3046 {
3047 phys[i] = sin(xc[i]) * cos(yc[i]) * sin(zc[i]);
3048 }
3049 Exp->PhysDeriv(phys, tmp = diff1, tmp1 = diff1 + (nelmts)*nq,
3050 tmp2 = diff1 + (2 * nelmts) * nq);
3051 for (int i = 1; i < nelmts; ++i)
3052 {
3053 Vmath::Vcopy(nq, phys, 1, tmp = phys + i * nq, 1);
3054 Exp->PhysDeriv(phys, tmp = diff1 + i * nq,
3055 tmp1 = diff1 + (nelmts + i) * nq,
3056 tmp2 = diff1 + (2 * nelmts + i) * nq);
3057 }
3058
3059 c.ApplyOperator(Collections::ePhysDeriv, phys, diff2,
3060 tmp = diff2 + nelmts * nq, tmp2 = diff2 + 2 * nelmts * nq);
3061
3062 double epsilon = 1.0e-8;
3063 for (int i = 0; i < diff1.size(); ++i)
3064 {
3065 BOOST_CHECK_CLOSE(diff1[i], diff2[i], epsilon);
3066 }
3067}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::Collections::Collection::ApplyOperator(), CreateHex(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::Collections::ePhysDeriv, Nektar::Collections::eSumFac, Nektar::Collections::CollectionOptimisation::GetOperatorImpMap(), Nektar::Collections::Collection::Initialise(), and Vmath::Vcopy().

◆ CreateHex()

SpatialDomains::HexGeomSharedPtr Nektar::HexCollectionTests::CreateHex ( SpatialDomains::PointGeomSharedPtr  v0,
SpatialDomains::PointGeomSharedPtr  v1,
SpatialDomains::PointGeomSharedPtr  v2,
SpatialDomains::PointGeomSharedPtr  v3,
SpatialDomains::PointGeomSharedPtr  v4,
SpatialDomains::PointGeomSharedPtr  v5,
SpatialDomains::PointGeomSharedPtr  v6,
SpatialDomains::PointGeomSharedPtr  v7 
)

Definition at line 56 of file TestHexCollection.cpp.

65{
66 Nektar::SpatialDomains::SegGeomSharedPtr e0 = CreateSegGeom(0, v0, v1);
67 Nektar::SpatialDomains::SegGeomSharedPtr e1 = CreateSegGeom(1, v1, v2);
68 Nektar::SpatialDomains::SegGeomSharedPtr e2 = CreateSegGeom(2, v2, v3);
69 Nektar::SpatialDomains::SegGeomSharedPtr e3 = CreateSegGeom(3, v3, v0);
70 Nektar::SpatialDomains::SegGeomSharedPtr e4 = CreateSegGeom(4, v0, v4);
71 Nektar::SpatialDomains::SegGeomSharedPtr e5 = CreateSegGeom(5, v1, v5);
72 Nektar::SpatialDomains::SegGeomSharedPtr e6 = CreateSegGeom(6, v2, v6);
73 Nektar::SpatialDomains::SegGeomSharedPtr e7 = CreateSegGeom(7, v3, v7);
74 Nektar::SpatialDomains::SegGeomSharedPtr e8 = CreateSegGeom(8, v4, v5);
75 Nektar::SpatialDomains::SegGeomSharedPtr e9 = CreateSegGeom(9, v5, v6);
76 Nektar::SpatialDomains::SegGeomSharedPtr e10 = CreateSegGeom(10, v6, v7);
77 Nektar::SpatialDomains::SegGeomSharedPtr e11 = CreateSegGeom(11, v4, v7);
78
79 Nektar::SpatialDomains::SegGeomSharedPtr
80 edgesF0[Nektar::SpatialDomains::QuadGeom::kNedges] = {e0, e1, e2, e3};
81 Nektar::SpatialDomains::SegGeomSharedPtr
82 edgesF1[Nektar::SpatialDomains::QuadGeom::kNedges] = {e0, e5, e8, e4};
83 Nektar::SpatialDomains::SegGeomSharedPtr
84 edgesF2[Nektar::SpatialDomains::QuadGeom::kNedges] = {e1, e6, e9, e5};
85 Nektar::SpatialDomains::SegGeomSharedPtr
86 edgesF3[Nektar::SpatialDomains::QuadGeom::kNedges] = {e2, e6, e10, e7};
87 Nektar::SpatialDomains::SegGeomSharedPtr
88 edgesF4[Nektar::SpatialDomains::QuadGeom::kNedges] = {e3, e7, e11, e4};
89 Nektar::SpatialDomains::SegGeomSharedPtr
90 edgesF5[Nektar::SpatialDomains::QuadGeom::kNedges] = {e8, e9, e10, e11};
91
92 Nektar::SpatialDomains::QuadGeomSharedPtr face0(
93 new SpatialDomains::QuadGeom(0, edgesF0));
94 Nektar::SpatialDomains::QuadGeomSharedPtr face1(
95 new SpatialDomains::QuadGeom(1, edgesF1));
96 Nektar::SpatialDomains::QuadGeomSharedPtr face2(
97 new SpatialDomains::QuadGeom(2, edgesF2));
98 Nektar::SpatialDomains::QuadGeomSharedPtr face3(
99 new SpatialDomains::QuadGeom(3, edgesF3));
100 Nektar::SpatialDomains::QuadGeomSharedPtr face4(
101 new SpatialDomains::QuadGeom(4, edgesF4));
102 Nektar::SpatialDomains::QuadGeomSharedPtr face5(
103 new SpatialDomains::QuadGeom(5, edgesF5));
104
105 Nektar::SpatialDomains::QuadGeomSharedPtr qfaces[] = {face0, face1, face2,
106 face3, face4, face5};
107 SpatialDomains::HexGeomSharedPtr hexGeom(
108 new SpatialDomains::HexGeom(0, qfaces));
109 return hexGeom;
110}
Nektar::SpatialDomains::QuadGeom::kNedges
static const int kNedges
Definition: QuadGeom.h:76
Nektar::HexCollectionTests::CreateSegGeom
SpatialDomains::SegGeomSharedPtr CreateSegGeom(unsigned int id, SpatialDomains::PointGeomSharedPtr v0, SpatialDomains::PointGeomSharedPtr v1)
Definition: TestHexCollection.cpp:46
Nektar::SpatialDomains::QuadGeomSharedPtr
std::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: HexGeom.h:47
Nektar::SpatialDomains::SegGeomSharedPtr
std::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:62

References CreateSegGeom(), and Nektar::SpatialDomains::QuadGeom::kNedges.

Referenced by BOOST_AUTO_TEST_CASE().

◆ CreateSegGeom()

SpatialDomains::SegGeomSharedPtr Nektar::HexCollectionTests::CreateSegGeom ( unsigned int  id,
SpatialDomains::PointGeomSharedPtr  v0,
SpatialDomains::PointGeomSharedPtr  v1 
)

Definition at line 46 of file TestHexCollection.cpp.

49{
50 SpatialDomains::PointGeomSharedPtr vertices[] = {v0, v1};
51 SpatialDomains::SegGeomSharedPtr result(
52 new SpatialDomains::SegGeom(id, 3, vertices));
53 return result;
54}

Referenced by CreateHex().

Generated on Wed Jan 31 2024 08:26:55 for Nektar++ by doxygen 1.9.4