GenericLocalAssemblerFactory.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <memory>
#include <typeindex>
#include <unordered_map>
 
#include "NumLib/DOF/LocalToGlobalIndexMap.h"
#include "NumLib/Fem/Integration/IntegrationMethodProvider.h"
 
namespace ProcessLib
{
template <typename T>
concept IntegrationMethodProviderOrIntegrationOrder =
    NumLib::IntegrationMethodProvider<T> ||
    std::same_as<T, NumLib::IntegrationOrder>;
 
template <typename LocalAssemblerInterface,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          typename... ConstructorArgs>
struct GenericLocalAssemblerFactory
{
    using LocAsmIntfPtr = std::unique_ptr<LocalAssemblerInterface>;
    using LocAsmBuilder = std::function<LocAsmIntfPtr(
        MeshLib::Element const& e,
        std::size_t const local_matrix_size,
        IntegrationMethodProvider const& integration_method_provider,
        ConstructorArgs&&...)>;
 
protected:  // only allow instances of subclasses
    explicit GenericLocalAssemblerFactory(
        NumLib::LocalToGlobalIndexMap const& dof_table,
        IntegrationMethodProvider const& integration_method_provider)
        : _dof_table{dof_table},
          _integration_method_provider{integration_method_provider}
    {
    }
    explicit GenericLocalAssemblerFactory( {…}
 
public:
    LocAsmIntfPtr operator()(std::size_t const id,
                             MeshLib::Element const& mesh_item,
                             ConstructorArgs&&... args) const
    {
        auto const type_idx = std::type_index(typeid(mesh_item));
        auto const it = _builders.find(type_idx);
 
        if (it != _builders.end())
        {
            auto const num_local_dof = _dof_table.getNumberOfElementDOF(id);
            return it->second(mesh_item, num_local_dof,
                              _integration_method_provider,
                              std::forward<ConstructorArgs>(args)...);
        }
        OGS_FATAL(
            "You are trying to build a local assembler for an unknown mesh "
            "element type ({:s})."
            " Maybe you have disabled this mesh element type in your build "
            "configuration, or a mesh element order does not match shape "
            "function order given in the project file.",
            type_idx.name());
    }
    LocAsmIntfPtr operator()(std::size_t const id, {…}
 
private:
    NumLib::LocalToGlobalIndexMap const& _dof_table;
    IntegrationMethodProvider const& _integration_method_provider;
 
protected:
    std::unordered_map<std::type_index, LocAsmBuilder> _builders;
};
struct GenericLocalAssemblerFactory {…};
 
template <typename ShapeFunction, typename LocalAssemblerInterface,
          template <typename /* shp fct */, int /* global dim */>
          class LocalAssemblerImplementation,
          NumLib::IntegrationMethodProvider IntegrationMethodProvider,
          int GlobalDim, typename... ConstructorArgs>
class LocalAssemblerBuilderFactory
{
    using GLAF = GenericLocalAssemblerFactory<
        LocalAssemblerInterface, IntegrationMethodProvider, ConstructorArgs...>;
    using LocAsmIntfPtr = typename GLAF::LocAsmIntfPtr;
    using LocAsmBuilder = typename GLAF::LocAsmBuilder;
 
    using LocAsmImpl = LocalAssemblerImplementation<ShapeFunction, GlobalDim>;
 
    LocalAssemblerBuilderFactory() = 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 LocalAssemblerBuilderFactory {…};
 
}  // namespace ProcessLib