LocalAssemblerTraits.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cassert>
#include <type_traits>
 
#include "NumLib/Fem/ShapeMatrixPolicy.h"
 
namespace ProcessLib
{
 
namespace detail
{

template <typename ShpPol, unsigned NNodes, unsigned NodalDOF, int Dim>
struct LocalAssemblerTraitsFixed
{
private:
    template <int N, int M>
    using Matrix = typename ShpPol::template MatrixType<N, M>;
    template <int N>
    using Vector = typename ShpPol::template VectorType<N>;
 
public:
    using ShapeMatrices = typename ShpPol::ShapeMatrices;

    using MatrixDimDim = Matrix<Dim, Dim>;
 
    // TODO That only works if all process variables are single component
    //      and use the same shape functions.
    using LocalMatrix = Matrix<NNodes * NodalDOF, NNodes * NodalDOF>;
    using LocalVector = Vector<NNodes * NodalDOF>;

    using Vector1Comp = Vector<NNodes>;

    using LaplaceMatrix = Matrix<Dim * NodalDOF, Dim * NodalDOF>;

    template <typename Mat>
    static auto blockDimDim(Mat const& mat, unsigned top, unsigned left,
                            unsigned nrows, unsigned ncols)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == Dim && ncols == Dim);
            (void)nrows;
            (void)ncols;
            return mat.template block<Dim, Dim>(top, left);
        }
        else
        {
            assert(nrows == ncols);
            return mat.block(top, left, nrows, ncols);
        }
    }

    template <typename Mat>
    static auto blockDimDim(Mat& mat, unsigned top, unsigned left,
                            unsigned nrows, unsigned ncols)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == Dim && ncols == Dim);
            (void)nrows;
            (void)ncols;
            return mat.template block<Dim, Dim>(top, left);
        }
        else
        {
            assert(nrows == ncols);
            return mat.block(top, left, nrows, ncols);
        }
    }

    template <typename Mat>
    static auto blockShpShp(Mat const& mat, unsigned top, unsigned left,
                            unsigned nrows, unsigned ncols)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == NNodes && ncols == NNodes);
            (void)nrows;
            (void)ncols;
            return mat.template block<NNodes, NNodes>(top, left);
        }
        else
        {
            assert(nrows == ncols);
            return mat.block(top, left, nrows, ncols);
        }
    }

    template <typename Mat>
    static auto blockShpShp(Mat& mat, unsigned top, unsigned left,
                            unsigned nrows, unsigned ncols)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == NNodes && ncols == NNodes);
            (void)nrows;
            (void)ncols;
            return mat.template block<NNodes, NNodes>(top, left);
        }
        else
        {
            assert(nrows == ncols);
            return mat.block(top, left, nrows, ncols);
        }
    }

    template <typename Vec>
    static auto blockShp(Vec const& vec, unsigned top, unsigned nrows)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == NNodes);
            (void)nrows;
            return vec.template block<NNodes, 1>(top, 0);
        }
        else
        {
            return vec.block(top, 0, nrows, 1);
        }
    }

    template <typename Vec>
    static auto blockShp(Vec& vec, unsigned top, unsigned nrows)
    {
        if constexpr (NodalDOF != 0)
        {
            assert(nrows == NNodes);
            (void)nrows;
            return vec.template block<NNodes, 1>(top, 0);
        }
        else
        {
            return vec.block(top, 0, nrows, 1);
        }
    }
};
 
}  // namespace detail
 
#ifndef OGS_EIGEN_DYNAMIC_SHAPE_MATRICES
 
template <typename ShpPol, unsigned NNodes, unsigned NodalDOF, int Dim>
using LocalAssemblerTraits =
    detail::LocalAssemblerTraitsFixed<ShpPol, NNodes, NodalDOF, Dim>;
 
static_assert(OGS_EIGEN_DYNAMIC_SHAPE_MATRICES_FLAG == 0,
              "Inconsistent use of the macro OGS_EIGEN_DYNAMIC_SHAPE_MATRICES."
              " Maybe you forgot to include some header file.");
#else
 
template <typename ShpPol, unsigned NNodes, unsigned NodalDOF, int Dim>
using LocalAssemblerTraits =
    detail::LocalAssemblerTraitsFixed<ShapeMatrixPolicyType<void, 0>, 0, 0, 0>;
 
static_assert(OGS_EIGEN_DYNAMIC_SHAPE_MATRICES_FLAG == 1,
              "Inconsistent use of the macro OGS_EIGEN_DYNAMIC_SHAPE_MATRICES."
              " Maybe you forgot to include some header file.");
#endif
 
}  // namespace ProcessLib