IntegrationPointWriter.h

Go to the documentation of this file.

 
#include <algorithm>
#include <functional>
#include <iterator>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "IntegrationPointMetaData.h"
 
#pragma once
 
namespace MeshLib
{
class Mesh;
class Properties;
 
struct IntegrationPointWriter final
{
    template <typename LocalAssemblerInterface, typename... Args>
    IntegrationPointWriter(
        std::string const& name,
        int const n_components,
        int const integration_order,
        std::vector<std::unique_ptr<LocalAssemblerInterface>> const&
            local_assemblers,
        std::vector<double> (LocalAssemblerInterface::*getIpData)(Args...)
            const,
        Args&&... args)
        : _name(name),
          _n_components(n_components),
          _integration_order(integration_order)
    {
        _callback = [&local_assemblers,
                     getIpData,
                     ... f_args = std::forward<Args>(args)]
        {
            // Result containing integration point data for each local
            // assembler.
            std::vector<std::vector<double>> result;
            result.reserve(local_assemblers.size());
 
            std::transform(begin(local_assemblers), end(local_assemblers),
                           std::back_inserter(result),
                           [&](auto const& la)
                           { return (*la.*getIpData)(f_args...); });
 
            return result;
        };
    }
    IntegrationPointWriter( {…}
 
    template <typename LocalAssemblerInterface, typename Accessor>
    IntegrationPointWriter(
        std::string const& name,
        int const n_components,
        int const integration_order,
        std::vector<std::unique_ptr<LocalAssemblerInterface>> const&
            local_assemblers,
        Accessor accessor)
        : _name(name),
          _n_components(n_components),
          _integration_order(integration_order)
    {
        _callback = [&local_assemblers, accessor]
        {
            // Result containing integration point data for each local
            // assembler.
            std::vector<std::vector<double>> result;
            result.reserve(local_assemblers.size());
 
            std::transform(begin(local_assemblers), end(local_assemblers),
                           std::back_inserter(result),
                           [&accessor](auto const& la)
                           { return accessor(*la); });
 
            return result;
        };
    }
    IntegrationPointWriter( {…}
 
    int numberOfComponents() const { return _n_components; }
    int integrationOrder() const { return _integration_order; }
    std::string name() const { return _name; }
    std::vector<std::vector<double>> values() const { return _callback(); }
 
private:
    std::string const _name;
    int const _n_components;
    int const _integration_order;
    std::function<std::vector<std::vector<double>>()> _callback;
};
struct IntegrationPointWriter final {…};
 
void addIntegrationPointDataToMesh(
    MeshLib::Mesh& mesh,
    std::vector<std::unique_ptr<IntegrationPointWriter>> const&
        integration_point_writer);
 
std::optional<IntegrationPointMetaData> getIntegrationPointMetaData(
    MeshLib::Properties const& properties);
}  // namespace MeshLib