LocalAssemblerFactoryTaylorHood.h

Go to the documentation of this file.

 
#pragma once
 
#include "EnabledElements.h"
#include "GenericLocalAssemblerFactory.h"
 
namespace ProcessLib
{
template <typename ShapeFunction,
          typename LowerOrderShapeFunction,
          typename LocalAssemblerInterface,
          template <typename /* shp fct */,
                    typename /* lower order shp fct */,
                    typename /* int meth */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          int GlobalDim,
          typename... ConstructorArgs>
class LocalAssemblerBuilderFactoryTaylorHood
{
    using GLAF = GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                              ConstructorArgs...>;
    using LocAsmIntfPtr = typename GLAF::LocAsmIntfPtr;
    using LocAsmBuilder = typename GLAF::LocAsmBuilder;
 
    using IntegrationMethod = typename NumLib::GaussLegendreIntegrationPolicy<
        typename ShapeFunction::MeshElement>::IntegrationMethod;
 
    using LocAsmImpl = LocalAssemblerImplementation<ShapeFunction,
                                                    LowerOrderShapeFunction,
                                                    IntegrationMethod,
                                                    GlobalDim>;
 
    LocalAssemblerBuilderFactoryTaylorHood() = delete;
 
public:
    static LocAsmBuilder create()
    {
        return [](MeshLib::Element const& e,
                  std::size_t const local_matrix_size,
                  ConstructorArgs&&... args)
        {
            return std::make_unique<LocAsmImpl>(
                e, local_matrix_size, std::forward<ConstructorArgs>(args)...);
        };
    }
};
 
template <int MinShapeFctOrder,
          int MinElementDim,
          typename LocalAssemblerInterface,
          template <typename /* shp fct */,
                    typename /* lower order shp fct */,
                    typename /* int meth */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          int GlobalDim,
          typename... ConstructorArgs>
class LocalAssemblerFactoryTaylorHood final
    : public ProcessLib::GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                                      ConstructorArgs...>
{
    using Base =
        ProcessLib::GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                                 ConstructorArgs...>;
 
    template <typename ShapeFunction, typename LowerOrderShapeFunction>
    using LocAsmBuilderFactory =
        LocalAssemblerBuilderFactoryTaylorHood<ShapeFunction,
                                               LowerOrderShapeFunction,
                                               LocalAssemblerInterface,
                                               LocalAssemblerImplementation,
                                               GlobalDim,
                                               ConstructorArgs...>;
 
    struct IsElementEnabled
    {
        template <typename ElementTraits>
        constexpr bool operator()(ElementTraits*) const
        {
            if constexpr (GlobalDim < ElementTraits::ShapeFunction::DIM)
            {
                return false;
            }
 
            if constexpr (ElementTraits::Element::dimension < MinElementDim)
            {
                return false;
            }
 
            return ElementTraits::ShapeFunction::ORDER >= MinShapeFctOrder;
        }
    };
 
public:
    explicit LocalAssemblerFactoryTaylorHood(
        NumLib::LocalToGlobalIndexMap const& dof_table)
        : Base(dof_table)
    {
        using EnabledElementTraits =
            decltype(BaseLib::TMP::filter<EnabledElementTraitsLagrange>(
                std::declval<IsElementEnabled>()));
 
        BaseLib::TMP::foreach<EnabledElementTraits>(
            [this]<typename ET>(ET*)
            {
                using MeshElement = typename ET::Element;
                using ShapeFunction = typename ET::ShapeFunction;
                using LowerOrderShapeFunction =
                    typename ET::LowerOrderShapeFunction;
 
                Base::_builders[std::type_index(typeid(MeshElement))] =
                    LocAsmBuilderFactory<ShapeFunction,
                                         LowerOrderShapeFunction>::create();
            });
    }
};
 
template <typename LocalAssemblerInterface,
          template <typename, typename, typename, int>
          class LocalAssemblerImplementation,
          int GlobalDim,
          typename... ConstructorArgs>
using LocalAssemblerFactoryHM =
    LocalAssemblerFactoryTaylorHood<1 /* also on linear elements */,
                                    2 /* only in 2D and 3D */,
                                    LocalAssemblerInterface,
                                    LocalAssemblerImplementation,
                                    GlobalDim,
                                    ConstructorArgs...>;
 
template <typename LocalAssemblerInterface,
          template <typename, typename, typename, int>
          class LocalAssemblerImplementation,
          int GlobalDim,
          typename... ConstructorArgs>
using LocalAssemblerFactoryStokes =
    LocalAssemblerFactoryTaylorHood<2 /* only for higher-order elements */,
                                    2 /* only in 2D and 3D */,
                                    LocalAssemblerInterface,
                                    LocalAssemblerImplementation,
                                    GlobalDim,
                                    ConstructorArgs...>;
 
}  // namespace ProcessLib