LocalAssemblerInterface.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <optional>
 
#include "MathLib/Point3d.h"
#include "NumLib/NumericsConfig.h"
 
namespace NumLib
{
class LocalToGlobalIndexMap;
}  // namespace NumLib
 
namespace ProcessLib
{
struct VectorSegment
{
    int start_index;
    int size;
};
class LocalAssemblerInterface
{
public:
    virtual ~LocalAssemblerInterface() = default;
 
    virtual void setInitialConditions(
        std::size_t const mesh_item_id,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_tables,
        std::vector<GlobalVector*> const& x, double const t,
        int const process_id);
 
    virtual void initialize(std::size_t const mesh_item_id,
                            NumLib::LocalToGlobalIndexMap const& dof_table);
 
    virtual void preAssemble(double const /*t*/, double const /*dt*/,
                             std::vector<double> const& /*local_x*/){};
 
    virtual void assemble(double const t, double const dt,
                          std::vector<double> const& local_x,
                          std::vector<double> const& local_x_prev,
                          std::vector<double>& local_M_data,
                          std::vector<double>& local_K_data,
                          std::vector<double>& local_b_data);
 
    virtual void assembleForStaggeredScheme(double const t, double const dt,
                                            Eigen::VectorXd const& local_x,
                                            Eigen::VectorXd const& local_x_prev,
                                            int const process_id,
                                            std::vector<double>& local_M_data,
                                            std::vector<double>& local_K_data,
                                            std::vector<double>& local_b_data);
 
    virtual void assembleWithJacobian(double const t, double const dt,
                                      std::vector<double> const& local_x,
                                      std::vector<double> const& local_x_prev,
                                      std::vector<double>& local_b_data,
                                      std::vector<double>& local_Jac_data);
 
    virtual void assembleWithJacobianForStaggeredScheme(
        double const t, double const dt, Eigen::VectorXd const& local_x,
        Eigen::VectorXd const& local_x_prev, int const process_id,
        std::vector<double>& local_b_data, std::vector<double>& local_Jac_data);
 
    virtual void computeSecondaryVariable(
        std::size_t const mesh_item_id,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_tables,
        double const t, double const dt, std::vector<GlobalVector*> const& x,
        GlobalVector const& x_prev, int const process_id);
 
    virtual void preTimestep(std::size_t const mesh_item_id,
                             NumLib::LocalToGlobalIndexMap const& dof_table,
                             GlobalVector const& x, double const t,
                             double const delta_t);
 
    virtual void postTimestep(
        std::size_t const mesh_item_id,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_tables,
        std::vector<GlobalVector*> const& x,
        std::vector<GlobalVector*> const& x_prev, double const t,
        double const dt, int const process_id);
 
    void postNonLinearSolver(
        std::size_t const mesh_item_id,
        std::vector<NumLib::LocalToGlobalIndexMap const*> const& dof_tables,
        std::vector<GlobalVector*> const& x,
        std::vector<GlobalVector*> const& x_prev, double const t,
        double const dt, int const process_id);
 
    virtual Eigen::Vector3d getFlux(
        MathLib::Point3d const& /*p_local_coords*/,
        double const /*t*/,
        std::vector<double> const& /*local_x*/) const
    {
        return Eigen::Vector3d{};
    }
 
    virtual Eigen::Vector3d getFlux(
        MathLib::Point3d const& /*p_local_coords*/,
        double const /*t*/,
        std::vector<std::vector<double>> const& /*local_xs*/) const
    {
        return Eigen::Vector3d{};
    }
 
    virtual std::optional<VectorSegment> getVectorDeformationSegment() const
    {
        return std::nullopt;
    }
 
private:
    virtual void setInitialConditionsConcrete(Eigen::VectorXd const /*local_x*/,
                                              double const /*t*/,
                                              int const /*process_id*/)
    {
    }
 
    virtual void initializeConcrete() {}
    virtual void preTimestepConcrete(std::vector<double> const& /*local_x*/,
                                     double const /*t*/, double const /*dt*/)
    {
    }
 
    virtual void postTimestepConcrete(Eigen::VectorXd const& /*local_x*/,
                                      Eigen::VectorXd const& /*local_x_prev*/,
                                      double const /*t*/, double const /*dt*/,
                                      int const /*process_id*/)
    {
    }
 
    virtual void postNonLinearSolverConcrete(
        Eigen::VectorXd const& /*local_x*/,
        Eigen::VectorXd const& /*local_x_prev*/, double const /*t*/,
        double const /*dt*/, int const /*process_id*/)
    {
    }
 
    virtual void computeSecondaryVariableConcrete(
        double const /*t*/,
        double const /*dt*/,
        Eigen::VectorXd const& /*local_x*/,
        Eigen::VectorXd const& /*local_x_prev*/)
    {
    }
};
 
}  // namespace ProcessLib