meshTests.h

Go to the documentation of this file.

#ifndef included_AMP_MeshTests
#define included_AMP_MeshTests
 
#include "AMP/discretization/simpleDOF_Manager.h"
#include "AMP/mesh/Mesh.h"
#include "AMP/utils/UnitTest.h"
#include "AMP/vectors/Variable.h"
#include "AMP/vectors/Vector.h"
#include "AMP/vectors/VectorBuilder.h"
#include "AMP/vectors/testHelpers/VectorTests.h"
 
 
namespace AMP::Mesh {
 
 
class meshTests
{
public:
    static void MeshTestLoop( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
    static void MeshGeometryTestLoop( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void MeshVectorTestLoop( AMP::UnitTest &ut,
                                    std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                    bool fast = false );
 
 
    static void MeshMatrixTestLoop( AMP::UnitTest &ut,
                                    std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                    bool fast = false );
 
public: // Basic tests
    static void testID( AMP::UnitTest &ut );
 
 
    static void testBoxMeshIndicies( AMP::UnitTest &ut, int ndim );
 
 
public: // Mesh based tests
    static void MeshIteratorTest( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void MeshIteratorOperationTest( AMP::UnitTest &ut,
                                           std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
    static void MeshIteratorSetOPTest( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
    static void MeshCountTest( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void MeshBasicTest( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void VerifyGhostIsOwned( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void VerifyBoundaryIDNodeIterator( AMP::UnitTest &ut,
                                              std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
    static void VerifyBoundaryIterator( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void testBlockIDs( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void getNodeNeighbors( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void DisplaceMeshScalar( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void DisplaceMeshVector( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void getParents( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
    static void cloneMesh( AMP::UnitTest &ut, std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
 
    static void testBoxMesh( AMP::UnitTest &ut, std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
 
    static void MeshPerformance( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
public: // Old tests
    static void VerifyNodeElemMapIteratorTest( AMP::UnitTest &ut,
                                               std::shared_ptr<AMP::Mesh::Mesh> mesh );
    static void VerifyBoundaryIteratorTest( AMP::UnitTest &ut,
                                            std::shared_ptr<AMP::Mesh::Mesh> mesh );
    static void VerifyElementForNode( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
public: // Geometry based tests
    static void TestBasicGeometry( AMP::UnitTest &ut, std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
    static void TestInside( AMP::UnitTest &ut, std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
    static void TestPhysicalLogical( AMP::UnitTest &ut,
                                     std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
    static void TestNormalGeometry( AMP::UnitTest &ut,
                                    std::shared_ptr<const AMP::Mesh::Mesh> mesh );
 
 
public: // Vector based tests
    class MeshVectorFactory : public AMP::LinearAlgebra::VectorFactory
    {
    public:
        MeshVectorFactory( std::shared_ptr<AMP::Mesh::Mesh> mesh,
                           AMP::Mesh::GeomType type,
                           int gcw,
                           int dofs_per_node,
                           bool split )
            : d_dofManager( AMP::Discretization::simpleDOFManager::create(
                  mesh, type, gcw, dofs_per_node, split ) ),
              SPLIT( split )
        {
        }
        AMP::LinearAlgebra::Vector::shared_ptr getVector() const override
        {
            auto var = std::make_shared<AMP::LinearAlgebra::Variable>( "test vector" );
            return AMP::LinearAlgebra::createVector( d_dofManager, var, SPLIT );
        }
        std::string name() const override { return "MeshVectorFactory"; }
 
    private:
        MeshVectorFactory();
        std::shared_ptr<AMP::Discretization::DOFManager> d_dofManager;
        bool SPLIT;
    };
 
    template<int DOF_PER_NODE, bool SPLIT>
    static void simpleNodalVectorTests( AMP::UnitTest &ut,
                                        std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                        std::shared_ptr<AMP::Discretization::DOFManager> DOFs,
                                        int gcw );
 
 
    template<int DOF_PER_NODE, bool SPLIT>
    static void VerifyGetVectorTest( AMP::UnitTest &ut, std::shared_ptr<AMP::Mesh::Mesh> mesh );
 
 
public: // Matrix based tests
    static void VerifyGetMatrixTrivialTest( AMP::UnitTest &ut,
                                            std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                            int dofsPerNode,
                                            bool split );
 
    static void RowWriteTest( AMP::UnitTest &ut,
                              std::shared_ptr<AMP::Mesh::Mesh> mesh,
                              int dofsPerNode,
                              bool split );
 
 
public:
    static std::pair<size_t, size_t> ElementIteratorTest( AMP::UnitTest &ut,
                                                          std::shared_ptr<AMP::Mesh::Mesh> mesh,
                                                          const AMP::Mesh::MeshIterator &iterator,
                                                          const AMP::Mesh::GeomType type,
                                                          const std::vector<int> &blockIds,
                                                          const std::string &name );
 
private:
    static std::shared_ptr<AMP::Mesh::Mesh> globalMeshForMeshVectorFactory;
};
 
 
} // namespace AMP::Mesh
 
// Extra includes
#include "AMP/mesh/testHelpers/meshVectorTests.inline.h"
 
 
#endif