Detailed Description

Copyright: Copyright (c) 2012-2024, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Definition in file IntegrationMethodRegistry.cpp.

#include "IntegrationMethodRegistry.h"
#include <unordered_map>
#include "BaseLib/Error.h"
#include "GaussLegendreIntegrationPolicy.h"
#include "MeshLib/Elements/Elements.h"

Include dependency graph for IntegrationMethodRegistry.cpp:

Go to the source code of this file.

Namespaces
namespace	NumLib

namespace	NumLib::IntegrationMethodRegistry

Typedefs
template<typename MeshElement >
using	IntegrationPolicy = NumLib::GaussLegendreIntegrationPolicy<MeshElement>

Functions
template<typename IntegrationPolicy_ >
static NumLib::GenericIntegrationMethod	createGenericIntegrationMethod (unsigned const order)

template<typename MeshElement >
static void	putIntegrationMethodsFor (std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &integration_methods_by_mesh_element_type, unsigned max_order)

static void	putIntegrationMethodsForDim0 (std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &integration_methods_by_mesh_element_type)

static void	putIntegrationMethodsForDim1 (std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &integration_methods_by_mesh_element_type)

static void	putIntegrationMethodsForDim2 (std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &integration_methods_by_mesh_element_type)

static void	putIntegrationMethodsForDim3 (std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &integration_methods_by_mesh_element_type)

static std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > >	initIntegrationMethods ()

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

Variables
static constexpr unsigned	MAX_ORDER_REGULAR = 4u

Typedef Documentation

◆ IntegrationPolicy

template<typename MeshElement >

using IntegrationPolicy = NumLib::GaussLegendreIntegrationPolicy<MeshElement>

Definition at line 21 of file IntegrationMethodRegistry.cpp.

Function Documentation

◆ createGenericIntegrationMethod()

template<typename IntegrationPolicy_ >

static NumLib::GenericIntegrationMethod createGenericIntegrationMethod ( unsigned const order )

static

Definition at line 24 of file IntegrationMethodRegistry.cpp.

{
    typename IntegrationPolicy_::IntegrationMethod meth{order};
    unsigned const np = meth.getNumberOfPoints();
 
    std::vector<MathLib::WeightedPoint> wps;
    wps.reserve(np);
 
    for (unsigned ip = 0; ip < np; ++ip)
    {
        wps.emplace_back(meth.getWeightedPoint(ip));
 
        if (wps.back() != meth.getWeightedPoint(ip))
        {
            throw std::runtime_error(
                "createGenericIntegrationMethod mismatch for ip=" +
                std::to_string(ip) + ", order=" + std::to_string(order) +
                ", method=" + typeid(decltype(meth)).name());
        }
    }
 
    return NumLib::GenericIntegrationMethod{order, std::move(wps)};
}

References NumLib::GenericIntegrationMethod::getNumberOfPoints().

Referenced by putIntegrationMethodsFor().

◆ initIntegrationMethods()

static std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > initIntegrationMethods ( )

static

Definition at line 159 of file IntegrationMethodRegistry.cpp.

{
    std::unordered_map<std::type_index,
                       std::vector<NumLib::GenericIntegrationMethod>>
        integration_methods_by_mesh_element_type;
 
    putIntegrationMethodsForDim0(integration_methods_by_mesh_element_type);
    putIntegrationMethodsForDim1(integration_methods_by_mesh_element_type);
    putIntegrationMethodsForDim2(integration_methods_by_mesh_element_type);
    putIntegrationMethodsForDim3(integration_methods_by_mesh_element_type);
 
    return integration_methods_by_mesh_element_type;
}

References putIntegrationMethodsForDim0(), putIntegrationMethodsForDim1(), putIntegrationMethodsForDim2(), and putIntegrationMethodsForDim3().

Referenced by NumLib::IntegrationMethodRegistry::getIntegrationMethod().

◆ putIntegrationMethodsFor()

template<typename MeshElement >

static void putIntegrationMethodsFor	(	std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > &	integration_methods_by_mesh_element_type,
		unsigned	max_order )

static

Definition at line 50 of file IntegrationMethodRegistry.cpp.

{
    std::vector<NumLib::GenericIntegrationMethod> integration_methods;
    integration_methods.reserve(max_order + 1);
 
    // order 0 -> no valid weighted points
    NumLib::GenericIntegrationMethod invalidMethod{0, {}};
    integration_methods.push_back(std::move(invalidMethod));
 
    for (unsigned order = 1; order <= max_order; ++order)
    {
        integration_methods.push_back(
            createGenericIntegrationMethod<IntegrationPolicy<MeshElement>>(
                order));
    }
 
    integration_methods_by_mesh_element_type.emplace(
        std::type_index(typeid(MeshElement)), std::move(integration_methods));
}

References createGenericIntegrationMethod().

◆ putIntegrationMethodsForDim0()

static void putIntegrationMethodsForDim0 ( std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > & integration_methods_by_mesh_element_type )

static

Definition at line 74 of file IntegrationMethodRegistry.cpp.

{
    putIntegrationMethodsFor<MeshLib::Point>(
        integration_methods_by_mesh_element_type,
        MAX_ORDER_REGULAR /* arbitrary cutoff */);
}

References MAX_ORDER_REGULAR.

Referenced by initIntegrationMethods().

◆ putIntegrationMethodsForDim1()

static void putIntegrationMethodsForDim1 ( std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > & integration_methods_by_mesh_element_type )

static

Definition at line 84 of file IntegrationMethodRegistry.cpp.

{
    putIntegrationMethodsFor<MeshLib::Line>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Line3>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
}

References MAX_ORDER_REGULAR.

Referenced by initIntegrationMethods().

◆ putIntegrationMethodsForDim2()

static void putIntegrationMethodsForDim2 ( std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > & integration_methods_by_mesh_element_type )

static

Definition at line 96 of file IntegrationMethodRegistry.cpp.

{
    putIntegrationMethodsFor<MeshLib::Quad>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Quad8>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Quad9>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Tri>(
        integration_methods_by_mesh_element_type, 4);
 
    putIntegrationMethodsFor<MeshLib::Tri6>(
        integration_methods_by_mesh_element_type, 4);
}

References MAX_ORDER_REGULAR.

Referenced by initIntegrationMethods().

◆ putIntegrationMethodsForDim3()

static void putIntegrationMethodsForDim3 ( std::unordered_map< std::type_index, std::vector< NumLib::GenericIntegrationMethod > > & integration_methods_by_mesh_element_type )

static

Definition at line 117 of file IntegrationMethodRegistry.cpp.

{
    putIntegrationMethodsFor<MeshLib::Hex>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Hex20>(
        integration_methods_by_mesh_element_type, MAX_ORDER_REGULAR);
 
    putIntegrationMethodsFor<MeshLib::Tet>(
        integration_methods_by_mesh_element_type, 4);
 
    putIntegrationMethodsFor<MeshLib::Tet10>(
        integration_methods_by_mesh_element_type, 4);
 
    putIntegrationMethodsFor<MeshLib::Prism>(
        integration_methods_by_mesh_element_type, 4);
 
    putIntegrationMethodsFor<MeshLib::Prism15>(
        integration_methods_by_mesh_element_type, 4);
 
    /* Note: Currently (July 22) OGS has pyramid integration schemes only up to
     * order 3 (see MathLib/Integration/GaussLegendrePyramid.h), and for order 4
     * the third order is re-used (see
     * NumLib/Fem/Integration/IntegrationGaussLegendrePyramid.h).
     * I.e., a user can request 4th order integration on pyramids and OGS will
     * just run fine, albeit with a lower integration order.
     * To keep that behavior, in particular not crash if a user requests 4th
     * order pyramid integration, we set the limit to 4, here.
     */
 
    putIntegrationMethodsFor<MeshLib::Pyramid>(
        integration_methods_by_mesh_element_type, 4 /* see note above */);
 
    putIntegrationMethodsFor<MeshLib::Pyramid13>(
        integration_methods_by_mesh_element_type, 4 /* see note above */);
}