ConstraintDirichletBoundaryCondition.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include "BoundaryCondition.h"
#include "ConstraintDirichletBoundaryConditionLocalAssembler.h"
#include "NumLib/DOF/LocalToGlobalIndexMap.h"
#include "NumLib/IndexValueVector.h"
#include "ParameterLib/Parameter.h"
 
namespace ProcessLib
{
class ConstraintDirichletBoundaryCondition final : public BoundaryCondition
{
public:
    ConstraintDirichletBoundaryCondition(
        ParameterLib::Parameter<double> const& parameter,
        NumLib::LocalToGlobalIndexMap const& dof_table_bulk,
        int const variable_id, int const component_id,
        MeshLib::Mesh const& bc_mesh, unsigned const integration_order,
        MeshLib::Mesh const& bulk_mesh, double const constraint_threshold,
        bool const lower,
        std::function<Eigen::Vector3d(std::size_t const,
                                      MathLib::Point3d const&, double const,
                                      std::vector<GlobalVector*> const&)>
            getFlux);
 
    void preTimestep(double const t, std::vector<GlobalVector*> const& x,
                     int const process_id) override;
 
    void getEssentialBCValues(
        const double t, const GlobalVector& x,
        NumLib::IndexValueVector<GlobalIndexType>& bc_values) const override;
 
private:
    ParameterLib::Parameter<double> const& _parameter;

    std::unique_ptr<NumLib::LocalToGlobalIndexMap> _dof_table_boundary;
 
    int const _variable_id;
    int const _component_id;

    MeshLib::Mesh const& _bc_mesh;

    unsigned const _integration_order;

    std::vector<std::pair<std::size_t, unsigned>> _bulk_ids;

    std::vector<double> _flux_values;

    std::vector<std::unique_ptr<
        ConstraintDirichletBoundaryConditionLocalAssemblerInterface>>
        _local_assemblers;

    double const _constraint_threshold;

    bool const _lower;

    MeshLib::Mesh const& _bulk_mesh;

    std::function<Eigen::Vector3d(std::size_t const, MathLib::Point3d const&,
                                  double const,
                                  std::vector<GlobalVector*> const&)>
        _getFlux;
};
 
struct ConstraintDirichletBoundaryConditionConfig
{
    std::string constraint_type;
    std::string constraining_process_variable;
    double constraint_threshold;
    std::string constraint_direction;
    std::string parameter_name;
};
 
ConstraintDirichletBoundaryConditionConfig
parseConstraintDirichletBoundaryCondition(BaseLib::ConfigTree const& config);

std::unique_ptr<ConstraintDirichletBoundaryCondition>
createConstraintDirichletBoundaryCondition(
    ConstraintDirichletBoundaryConditionConfig const& config,
    MeshLib::Mesh const& bc_mesh,
    NumLib::LocalToGlobalIndexMap const& dof_table_bulk, int const variable_id,
    unsigned const integration_order, int const component_id,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
    Process const& constraining_process);
}  // namespace ProcessLib