ExtrapolatableElementCollection.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <vector>
 
#include "ExtrapolatableElement.h"
#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
 
namespace NumLib
{
class LocalToGlobalIndexMap;
 
class ExtrapolatableElementCollection
{
public:
    virtual Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
        std::size_t const id, unsigned const integration_point) const = 0;
 
    virtual std::vector<double> const& getIntegrationPointValues(
        std::size_t const id, const double t,
        std::vector<GlobalVector*> const& x,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
        std::vector<double>& cache) const = 0;
 
    virtual std::size_t size() const = 0;
 
    virtual ~ExtrapolatableElementCollection() = default;
};
class ExtrapolatableElementCollection {…};
 
template <typename LocalAssemblerCollection>
class ExtrapolatableLocalAssemblerCollection
    : public ExtrapolatableElementCollection
{
public:
    using LocalAssembler =
        typename std::decay_t<decltype(*std::declval<LocalAssemblerCollection>()
                                           [static_cast<std::size_t>(0)])>;
 
    static_assert(std::is_base_of<ExtrapolatableElement, LocalAssembler>::value,
                  "Local assemblers used for extrapolation must be derived "
                  "from ExtrapolatableElement.");
 
    using IntegrationPointValuesMethod =
        std::function<std::vector<double> const&(
            LocalAssembler const& loc_asm, const double t,
            std::vector<GlobalVector*> const& x,
            std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
            std::vector<double>& cache)>;
 
    ExtrapolatableLocalAssemblerCollection(
        LocalAssemblerCollection const& local_assemblers,
        IntegrationPointValuesMethod const& integration_point_values_method)
        : _local_assemblers(local_assemblers),
          _integration_point_values_method{integration_point_values_method}
    {
    }
    ExtrapolatableLocalAssemblerCollection( {…}
 
    Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
        std::size_t const id, unsigned const integration_point) const override
    {
        ExtrapolatableElement const& loc_asm = *_local_assemblers[id];
        return loc_asm.getShapeMatrix(integration_point);
    }
    Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix( {…}
 
    std::vector<double> const& getIntegrationPointValues(
        std::size_t const id, const double t,
        std::vector<GlobalVector*> const& x,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_table,
        std::vector<double>& cache) const override
    {
        auto const& loc_asm = *_local_assemblers[id];
        return _integration_point_values_method(loc_asm, t, x, dof_table,
                                                cache);
    }
    std::vector<double> const& getIntegrationPointValues( {…}
 
    std::size_t size() const override { return _local_assemblers.size(); }
 
private:
    LocalAssemblerCollection const& _local_assemblers;
    IntegrationPointValuesMethod const _integration_point_values_method;
};
class ExtrapolatableLocalAssemblerCollection {…};
 
template <typename LocalAssemblerCollection,
          typename IntegrationPointValuesMethod>
ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>
makeExtrapolatable(LocalAssemblerCollection const& local_assemblers,
                   IntegrationPointValuesMethod integration_point_values_method)
{
    return ExtrapolatableLocalAssemblerCollection<LocalAssemblerCollection>{
        local_assemblers, integration_point_values_method};
}
makeExtrapolatable(LocalAssemblerCollection const& local_assemblers, {…}
}  // namespace NumLib