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 */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          int GlobalDim,
          typename... ConstructorArgs>
class LocalAssemblerBuilderFactoryTaylorHood
{
    using GLAF = GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                              IntegrationMethodProvider,
                                              ConstructorArgs...>;
    using LocAsmIntfPtr = typename GLAF::LocAsmIntfPtr;
    using LocAsmBuilder = typename GLAF::LocAsmBuilder;
 
    using LocAsmImpl = LocalAssemblerImplementation<ShapeFunction,
                                                    LowerOrderShapeFunction,
                                                    GlobalDim>;
 
    LocalAssemblerBuilderFactoryTaylorHood() = delete;
 
public:
    template <typename MeshElement>
    static LocAsmBuilder create()
    {
        return [](MeshLib::Element const& e,
                  std::size_t const local_matrix_size,
                  IntegrationMethodProvider const& integration_method_provider,
                  ConstructorArgs&&... args)
        {
            auto const& integration_method =
                integration_method_provider
                    .template getIntegrationMethod<MeshElement>(e);
 
            static_assert(!std::is_abstract_v<LocAsmImpl>,
                          "The given local assembler implementation is an "
                          "abstract class, which cannot be instantiated. Make "
                          "sure to implement all virtual methods!");
 
            static_assert(std::is_constructible_v<LocAsmImpl,
                                                  MeshLib::Element const&,
                                                  std::size_t,
                                                  decltype(integration_method),
                                                  ConstructorArgs&&...>,
                          "The given local assembler implementation is not "
                          "constructible from the provided arguments.");
 
            return std::make_unique<LocAsmImpl>(
                e,
                local_matrix_size,
                integration_method,
                std::forward<ConstructorArgs>(args)...);
        };
    }
    static LocAsmBuilder create() {…}
};
class LocalAssemblerBuilderFactoryTaylorHood {…};
 
template <int MinShapeFctOrder,
          int MinElementDim,
          typename LocalAssemblerInterface,
          template <typename /* shp fct */,
                    typename /* lower order shp fct */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          int GlobalDim,
          typename... ConstructorArgs>
class LocalAssemblerFactoryTaylorHood final
    : public ProcessLib::GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                                      IntegrationMethodProvider,
                                                      ConstructorArgs...>
{
    using Base =
        ProcessLib::GenericLocalAssemblerFactory<LocalAssemblerInterface,
                                                 IntegrationMethodProvider,
                                                 ConstructorArgs...>;
 
    template <typename ShapeFunction, typename LowerOrderShapeFunction>
    using LocAsmBuilderFactory =
        LocalAssemblerBuilderFactoryTaylorHood<ShapeFunction,
                                               LowerOrderShapeFunction,
                                               LocalAssemblerInterface,
                                               LocalAssemblerImplementation,
                                               IntegrationMethodProvider,
                                               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;
        }
        constexpr bool operator()(ElementTraits*) const {…}
    };
    struct IsElementEnabled {…};
 
public:
    explicit LocalAssemblerFactoryTaylorHood(
        NumLib::LocalToGlobalIndexMap const& dof_table,
        IntegrationMethodProvider const& integration_method_provider)
        : Base{dof_table, integration_method_provider}
    {
        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>::
                        template create<MeshElement>();
            });
    }
    explicit LocalAssemblerFactoryTaylorHood( {…}
};
class LocalAssemblerFactoryTaylorHood final {…};
 
template <typename LocalAssemblerInterface,
          template <typename /* shp fct */,
                    typename /* lower order shp fct */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          int GlobalDim,
          typename... ConstructorArgs>
using LocalAssemblerFactoryHM =
    LocalAssemblerFactoryTaylorHood<1 /* also on linear elements */,
                                    2 /* only in 2D and 3D */,
                                    LocalAssemblerInterface,
                                    LocalAssemblerImplementation,
                                    IntegrationMethodProvider,
                                    GlobalDim,
                                    ConstructorArgs...>;
 
template <typename LocalAssemblerInterface,
          template <typename /* shp fct */,
                    typename /* lower order shp fct */,
                    int /* global dim */>
          class LocalAssemblerImplementation,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          int GlobalDim,
          typename... ConstructorArgs>
using LocalAssemblerFactoryStokes =
    LocalAssemblerFactoryTaylorHood<2 /* only for higher-order elements */,
                                    2 /* only in 2D and 3D */,
                                    LocalAssemblerInterface,
                                    LocalAssemblerImplementation,
                                    IntegrationMethodProvider,
                                    GlobalDim,
                                    ConstructorArgs...>;
 
}  // namespace ProcessLib