FiniteElementSpace.h

Go to the documentation of this file.

// FiniteElementSpace Class
//   This class is the interface for the solvers with the finite element methods implemented in
//   IPPL. The constructor takes in an IPPL mesh, a reference element and a quadrature rule. The
//   class is templated on the floating point type T, the dimension 'Dim' (1 for 1D, 2 for 2D, 3 for
//   3D), the number of degrees of freedom per element 'NumElementDOFs', the quadrature rule type
//   'QuadratureType', the left hand side field type 'FieldLHS' and the right hand side field type
//   'FieldRHS'.
 
#ifndef IPPL_FEMSPACE_H
#define IPPL_FEMSPACE_H
 
#include "Types/ViewTypes.h"
 
#include "Utility/IpplException.h"
 
#include "FEM/Elements/Element.h"
#include "FEM/Quadrature/Quadrature.h"
#include "Meshes/UniformCartesian.h"
 
namespace ippl {
 
    constexpr unsigned calculateNumElementVertices(unsigned Dim) {
        return 1 << Dim;  // 2^Dim
    }

    template <typename T, unsigned Dim, unsigned NumElementDOFs, typename ElementType,
              typename QuadratureType, typename FieldLHS, typename FieldRHS>
    // requires IsElement<QuadratureType>
    class FiniteElementSpace {
    public:
        static constexpr unsigned dim = Dim;
 
        // the number of mesh vertices per element (not necessarily the same as degrees of freedom,
        // e.g. a 2D element has 4 vertices)
        static constexpr unsigned numElementVertices = calculateNumElementVertices(Dim);
        static constexpr unsigned numElementDOFs     = NumElementDOFs;
 
        // A vector with the position of the element in the mesh in each dimension
        typedef Vector<size_t, Dim> indices_t;
 
        // A point in the global coordinate system
        typedef Vector<T, Dim> point_t;
 
        // A vector of vertex indices of the mesh
        typedef Vector<size_t, numElementVertices> vertex_indices_t;
 
        typedef Vector<indices_t, numElementVertices> indices_list_t;
 
        typedef Vector<point_t, numElementVertices> vertex_points_t;

        // Constructors ///////////////////////////////////////////////////////

        FiniteElementSpace(UniformCartesian<T, Dim>& mesh, ElementType& ref_element,
                           const QuadratureType& quadrature);
 
        void setMesh(UniformCartesian<T, Dim>& mesh);


        KOKKOS_FUNCTION size_t numElements() const;

        KOKKOS_FUNCTION size_t numElementsInDim(const size_t& dim) const;

        KOKKOS_FUNCTION indices_t getMeshVertexNDIndex(const size_t& vertex_index) const;

        KOKKOS_FUNCTION size_t getMeshVertexIndex(const indices_t& vertex_nd_index) const;

        KOKKOS_FUNCTION indices_t getElementNDIndex(const size_t& elementIndex) const;

        KOKKOS_FUNCTION size_t getElementIndex(const indices_t& ndindex) const;

        KOKKOS_FUNCTION vertex_indices_t
        getElementMeshVertexIndices(const indices_t& elementNDIndex) const;

        KOKKOS_FUNCTION indices_list_t
        getElementMeshVertexNDIndices(const indices_t& elementNDIndex) const;

        KOKKOS_FUNCTION vertex_points_t
        getElementMeshVertexPoints(const indices_t& elementNDIndex) const;


        KOKKOS_FUNCTION virtual size_t numGlobalDOFs() const = 0;

        KOKKOS_FUNCTION virtual size_t getLocalDOFIndex(const size_t& elementIndex,
                                         const size_t& globalDOFIndex) const = 0;

        KOKKOS_FUNCTION virtual size_t getGlobalDOFIndex(const size_t& elementIndex,
                                                         const size_t& localDOFIndex) const = 0;

        KOKKOS_FUNCTION virtual Vector<size_t, NumElementDOFs> getLocalDOFIndices() const = 0;

        KOKKOS_FUNCTION virtual Vector<size_t, NumElementDOFs> getGlobalDOFIndices(
            const size_t& elementIndex) const = 0;
 

 
        UniformCartesian<T, Dim>& mesh_m;
        ElementType ref_element_m;
        const QuadratureType& quadrature_m;
        Vector<size_t, Dim> nr_m;
        Vector<double, Dim> hr_m;
        Vector<double, Dim> origin_m;
    };
 
}  // namespace ippl
 
#include "FEM/FiniteElementSpace.hpp"
 
#endif