Classes
struct	BcAndStLocalAssemblerImpl
struct	BcOrStData
struct	FlagAndFluxAndDFlux
struct	NsAndWeight
struct	NsAndWeight< ShapeFunction, ShapeFunction, ShapeMatrix, ShapeMatrix >
struct	NsAndWeightsTraits
	Collects common type aliases needed when working with NsAndWeight. More...

Functions
Eigen::MatrixXd	collectDofsToMatrix (MeshLib::Element const &element, std::size_t const mesh_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x)
Eigen::VectorXd	collectDofsToMatrixOnBaseNodesSingleComponent (MeshLib::Element const &element, std::size_t const mesh_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, int const variable, int const component)
template<typename NsAndWeight>
void	interpolate (Eigen::MatrixXd const &primary_variables_mat, std::vector< std::reference_wrapper< ProcessVariable > > const &pv_refs, NsAndWeight const &ns_and_weight, Eigen::Ref< Eigen::VectorXd > interpolated_primary_variables)
template<typename ShapeFunction, typename LowerOrderShapeFunction, int GlobalDim, typename IntegrationMethod>
auto	computeNsAndWeights (MeshLib::Element const &element, bool const is_axially_symmetric, IntegrationMethod const &integration_method)

Function Documentation

◆ collectDofsToMatrix()

Eigen::MatrixXd ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrix	(	MeshLib::Element const &	element,
		std::size_t const	mesh_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		GlobalVector const &	x )

Collects the degrees of freedom of the passed element from the passed global vector into a matrix.

The dimensions of the returned matrix are #nodes x #total_components, i.e., each row of the matrix will contain all degrees of freedom at a specific node of the passed element.

The order of nodes is determined by the passed element. The order of components is determined by the passed dof_table.

Note: OGS currently has implemented Lagrange finite elements only, i.e., all degrees of freedom are nodal degrees of freedom.; In the case of Taylor-Hood elements, some components are defined only on base nodes. In that case, the returned matrix might contain some uninitialized entries. It is the responsibility of the caller to handle the returned matrix correctly.

Definition at line 67 of file CollectAndInterpolateNodalDof.cpp.

{
    auto const num_var = dof_table.getNumberOfVariables();
    auto const num_nodes = element.getNumberOfNodes();
    auto const num_comp_total = dof_table.getNumberOfGlobalComponents();
 
    Eigen::MatrixXd primary_variables_mat(num_nodes, num_comp_total);
 
    for (int var = 0; var < num_var; ++var)
    {
        auto const num_comp = dof_table.getNumberOfVariableComponents(var);
 
        for (int comp = 0; comp < num_comp; ++comp)
        {
            auto const global_component =
                dof_table.getGlobalComponent(var, comp);
            auto all_nodal_dof_for_this_component =
                primary_variables_mat.col(global_component);
 
            collectDofsToMatrixSingleComponentForSomeNodes(
                element, mesh_id, dof_table, x, var, comp, num_nodes,
                all_nodal_dof_for_this_component);
        }
    }
 
    return primary_variables_mat;
}

References NumLib::LocalToGlobalIndexMap::getGlobalComponent(), NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), MeshLib::Element::getNumberOfNodes(), NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), and NumLib::LocalToGlobalIndexMap::getNumberOfVariables().

Referenced by ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::assemble().

◆ collectDofsToMatrixOnBaseNodesSingleComponent()

Eigen::VectorXd ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrixOnBaseNodesSingleComponent	(	MeshLib::Element const &	element,
		std::size_t const	mesh_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		GlobalVector const &	x,
		int const	variable,
		int const	component )

Does the same as collectDofsToMatrix(), just for a single component and only on the base nodes of the passed mesh element.

Definition at line 99 of file CollectAndInterpolateNodalDof.cpp.

{
    auto const num_nodes = element.getNumberOfBaseNodes();
    Eigen::VectorXd primary_variables_vec(num_nodes);
 
    collectDofsToMatrixSingleComponentForSomeNodes(
        element, mesh_id, dof_table, x, variable, component, num_nodes,
        primary_variables_vec);
 
    return primary_variables_vec;
}

References MeshLib::Element::getNumberOfBaseNodes().

Referenced by ProcessLib::PythonBoundaryConditionLocalAssembler< ShapeFunction, LowerOrderShapeFunction, GlobalDim >::interpolate().

◆ computeNsAndWeights()

template<typename ShapeFunction, typename LowerOrderShapeFunction, int GlobalDim, typename IntegrationMethod>

auto ProcessLib::BoundaryConditionAndSourceTerm::Python::computeNsAndWeights	(	MeshLib::Element const &	element,
		bool const	is_axially_symmetric,
		IntegrationMethod const &	integration_method )

Computes shape matrices and integration weights for all integration points in the given mesh element.

Note: This is an extension of GenericNaturalBoundaryConditionLocalAssembler::initNsAndWeights().

Definition at line 142 of file NsAndWeight.h.

{
    using Traits =
        NsAndWeightsTraits<ShapeFunction, LowerOrderShapeFunction, GlobalDim>;
    using VecOfNsAndWeight = std::vector<typename Traits::NsAndWeight>;
 
    VecOfNsAndWeight nss_and_weights;
    nss_and_weights.reserve(integration_method.getNumberOfPoints());
 
    auto sms =
        NumLib::initShapeMatrices<ShapeFunction,
                                  typename Traits::ShapeMatrixPolicy, GlobalDim,
                                  NumLib::ShapeMatrixType::N_J>(
            element, is_axially_symmetric, integration_method);
 
    if constexpr (std::is_same_v<ShapeFunction, LowerOrderShapeFunction>)
    {
        static_assert(ShapeFunction::ORDER < 2,
                      "We do not expect higher order shape functions here. "
                      "Something must have gone terribly wrong.");
 
        for (unsigned ip = 0; ip < sms.size(); ++ip)
        {
            auto& sm = sms[ip];
            double const w =
                sm.detJ * sm.integralMeasure *
                integration_method.getWeightedPoint(ip).getWeight();
 
            nss_and_weights.emplace_back(std::move(sm.N), w);
        }
    }
    else
    {
        auto sms_lower = NumLib::initShapeMatrices<
            LowerOrderShapeFunction,
            typename Traits::LowerOrderShapeMatrixPolicy, GlobalDim,
            NumLib::ShapeMatrixType::N>(element, is_axially_symmetric,
                                        integration_method);
 
        for (unsigned ip = 0; ip < sms.size(); ++ip)
        {
            auto& sm = sms[ip];
 
            // Note: we use det(J) of the higher order shape function. For
            // linear geometries (i.e., higher order elements but with flat
            // surfaces) there should be no difference.
            double const w =
                sm.detJ * sm.integralMeasure *
                integration_method.getWeightedPoint(ip).getWeight();
 
            nss_and_weights.emplace_back(std::move(sm.N),
                                         std::move(sms_lower[ip].N), w);
        }
    }
 
    return nss_and_weights;
}

References NumLib::initShapeMatrices(), NumLib::N, and NumLib::N_J.

Referenced by ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::BcAndStLocalAssemblerImpl().

◆ interpolate()

template<typename NsAndWeight>

void ProcessLib::BoundaryConditionAndSourceTerm::Python::interpolate	(	Eigen::MatrixXd const &	primary_variables_mat,
		std::vector< std::reference_wrapper< ProcessVariable > > const &	pv_refs,
		NsAndWeight const &	ns_and_weight,
		Eigen::Ref< Eigen::VectorXd >	interpolated_primary_variables )

Interpolates the passed matrix of degrees of freedom to the interpolated_primary_variables via the passed shape matrices in ns_and_weight.

The interpolation function order for each variable is determined by the passed ProcessVariable vector.

For the layout of primary_variables_mat see collectDofsToMatrix().

Definition at line 56 of file CollectAndInterpolateNodalDof.h.

{
    Eigen::Index component_flattened = 0;
 
    // We assume that all_process_variables_for_this_process have the same
    // order as the d.o.f. table. Therefore we can iterate over
    // all_process_variables_for_this_process.
    for (auto pv_ref : pv_refs)
    {
        auto const& pv = pv_ref.get();
        auto const num_comp = pv.getNumberOfGlobalComponents();
        auto const shp_fct_order = pv.getShapeFunctionOrder();
        auto const N = ns_and_weight.N(shp_fct_order);
 
        for (auto comp = decltype(num_comp){0}; comp < num_comp; ++comp)
        {
            // This computation assumes that there are no "holes" in the
            // primary_variables_mat. I.e., all nodal d.o.f. for a certain
            // (var, comp) must be stored contiguously in the respective column
            // of primary_variables_mat.
            interpolated_primary_variables[component_flattened] =
                N *
                primary_variables_mat.col(component_flattened).head(N.size());
            component_flattened++;
        }
    }
}

References ProcessLib::BoundaryConditionAndSourceTerm::Python::NsAndWeight< ShapeFunction, LowerOrderShapeFunction, ShapeMatrix, LowerOrderShapeMatrix >::N().