NumLib::IntegrationMethodRegistry Namespace Reference

Functions
GenericIntegrationMethod const &	getIntegrationMethod (std::type_index const mesh_element_type, IntegrationOrder const order)
template<typename MeshElement>
GenericIntegrationMethod const &	getIntegrationMethod (IntegrationOrder const order)
	Templated version of above method. Provided for convenience.

Function Documentation

getIntegrationMethod() [1/2]

template<typename MeshElement>

GenericIntegrationMethod const & NumLib::IntegrationMethodRegistry::getIntegrationMethod

(

IntegrationOrder const

order

)

Templated version of above method. Provided for convenience.

Definition at line 30 of file IntegrationMethodRegistry.h.

{
    return getIntegrationMethod(std::type_index(typeid(MeshElement)), order);
}

References getIntegrationMethod().

getIntegrationMethod() [2/2]

GenericIntegrationMethod const & NumLib::IntegrationMethodRegistry::getIntegrationMethod	(	std::type_index const	mesh_element_type,
		IntegrationOrder const	order )

Provides the default integration method for a given mesh element type and a given integration order.

Definition at line 170 of file IntegrationMethodRegistry.cpp.

{
    if (order.order == 0)
    {
        // For 0D elements (points) the order does not matter, still we don't
        // want order zero there. For all other element types integration order
        // does matter.
        OGS_FATAL("An integration order of 0 is not supported.");
    }
 
    // The actual integration method registry.
    //
    // A mapping \code [mesh element type] -> [list of integration
    // methods]\endcode, where each entry in the list corresponds to integration
    // order 0, 1, 2, ...
    //
    // Having this as a static __local__ variable circumvents the static
    // initialization order fiasco we would have if this was a static __global__
    // variable. The fiasco arises, because this registry uses static global
    // data from MathLib. Currently (Feb 2022) we cannot circumvent the problem
    // with constinit due to lack of compiler support.
    static const std::unordered_map<
        std::type_index,
        std::vector<NumLib::GenericIntegrationMethod>>
        integration_methods_by_mesh_element_type = initIntegrationMethods();
 
    if (auto it =
            integration_methods_by_mesh_element_type.find(mesh_element_type);
        it != integration_methods_by_mesh_element_type.end())
    {
        auto& integration_methods = it->second;
 
        if (order.order >= integration_methods.size())
        {
            OGS_FATAL(
                "Integration order {} is not supported for mesh elements of "
                "type {}",
                order.order,
                mesh_element_type.name());
        }
 
        return integration_methods[order.order];
    }
 
    OGS_FATAL(
        "No integration methods are available for mesh elements of type {}",
        mesh_element_type.name());
}

References initIntegrationMethods(), OGS_FATAL, and NumLib::IntegrationOrder::order.

Referenced by getIntegrationMethod(), and anonymous_namespace{ShapeMatrixCache.cpp}::initShapeMatrices().