CreateBoundaryCondition.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "CreateBoundaryCondition.h"
 
#include "BaseLib/Error.h"
#include "BaseLib/TimeInterval.h"
#include "BoundaryCondition.h"
#include "BoundaryConditionConfig.h"
#include "ConstraintDirichletBoundaryCondition.h"
#include "CreateDirichletBoundaryConditionWithinTimeInterval.h"
#include "CreateReleaseNodalForce.h"
#include "CreateTimeDecayDirichletBoundaryCondition.h"
#include "DirichletBoundaryCondition.h"
#include "HCNonAdvectiveFreeComponentFlowBoundaryCondition.h"
#include "NeumannBoundaryCondition.h"
#include "NormalTractionBoundaryCondition.h"
#include "ParameterLib/Parameter.h"
#include "PhaseFieldIrreversibleDamageOracleBoundaryCondition.h"
#include "PrimaryVariableConstraintDirichletBoundaryCondition.h"
#include "Python/PythonBoundaryCondition.h"
#include "RobinBoundaryCondition.h"
#include "SolutionDependentDirichletBoundaryCondition.h"
#include "VariableDependentNeumannBoundaryCondition.h"
#include "WellboreCompensateNeumannBoundaryCondition.h"
#include "WellboreCompensateNeumannBoundaryConditionLocalAssembler.h"
 
namespace ProcessLib
{
std::vector<std::unique_ptr<BoundaryCondition>> createBoundaryCondition(
    const BoundaryConditionConfig& config,
    const NumLib::LocalToGlobalIndexMap& dof_table,
    const MeshLib::Mesh& bulk_mesh, const int variable_id,
    const unsigned integration_order, const unsigned shapefunction_order,
    const std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
    const Process& process,
    [[maybe_unused]] std::vector<std::reference_wrapper<ProcessVariable>> const&
        all_process_variables_for_this_process,
    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
{
    // Surface mesh and bulk mesh must have equal axial symmetry flags!
    for (auto const& i : config.boundary_meshes)
    {
        if (i.get().isAxiallySymmetric() != bulk_mesh.isAxiallySymmetric())
        {
            OGS_FATAL(
                "The boundary mesh {:s} axially symmetric but the bulk mesh "
                "{:s}. "
                "Both must have an equal axial symmetry property.",
                i.get().isAxiallySymmetric() ? "is" : "is not",
                bulk_mesh.isAxiallySymmetric() ? "is" : "is not");
        }
    }
 
    std::vector<std::unique_ptr<BoundaryCondition>> boundary_conditions;

    auto const type = config.config.peekConfigParameter<std::string>("type");
 
    if (bool const component_id_required =
            !(type == "NormalTraction" || type == "ReleaseNodalForce");
        component_id_required && !config.component_id.has_value())
    {
        OGS_FATAL(
            "Specifying the component id (<component>) for a boundary "
            "condition of type {} is mandatory.",
            type);
    }
 
    if (type == "Dirichlet")
    {
        auto const parameter_name = parseDirichletBCConfig(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> dirichlet_conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            dirichlet_conditions.push_back(
                ProcessLib::createDirichletBoundaryCondition(
                    parameter_name, bc_mesh, dof_table, variable_id,
                    *config.component_id, parameters));
        }
        return dirichlet_conditions;
    }
    if (type == "DirichletWithinTimeInterval")
    {
        auto const config_args =
            parseDirichletBoundaryConditionWithinTimeIntervalConfig(
                config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createDirichletBoundaryConditionWithinTimeInterval(
                    config_args, bc_mesh, dof_table, variable_id,
                    *config.component_id, parameters));
        }
        return conditions;
    }
    if (type == "TimeDecayDirichlet")
    {
        auto const config_args =
            parseTimeDecayDirichletBoundaryConditionConfig(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createTimeDecayDirichletBoundaryCondition(
                    config_args, variable_id, *config.component_id, bc_mesh,
                    dof_table, parameters));
        }
        return conditions;
    }
    if (type == "Neumann")
    {
        auto const config_args = parseNeumannBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(ProcessLib::createNeumannBoundaryCondition(
                config_args, bc_mesh, dof_table, variable_id,
                *config.component_id, integration_order, shapefunction_order,
                bulk_mesh.getDimension(), parameters));
        }
        return conditions;
    }
    if (type == "Robin")
    {
        auto const config_args = parseRobinBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(ProcessLib::createRobinBoundaryCondition(
                config_args, bc_mesh, dof_table, variable_id,
                *config.component_id, integration_order, shapefunction_order,
                bulk_mesh.getDimension(), parameters));
        }
        return conditions;
    }
    if (type == "VariableDependentNeumann")
    {
        auto const config_args =
            parseVariableDependentNeumannBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createVariableDependentNeumannBoundaryCondition(
                    config_args, bc_mesh, dof_table, variable_id,
                    *config.component_id, integration_order,
                    shapefunction_order, bulk_mesh.getDimension(), parameters));
        }
        return conditions;
    }
    if (type == "Python")
    {
        auto const config_args = parsePythonBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(ProcessLib::createPythonBoundaryCondition(
                config_args, bc_mesh, dof_table, bulk_mesh, variable_id,
                *config.component_id, integration_order, shapefunction_order,
                all_process_variables_for_this_process));
        }
        return conditions;
    }
 
    //
    // Special boundary conditions
    //
    if (type == "ConstraintDirichlet")
    {
        auto const config_args =
            parseConstraintDirichletBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createConstraintDirichletBoundaryCondition(
                    config_args, bc_mesh, dof_table, variable_id,
                    integration_order, *config.component_id, parameters,
                    process));
        }
        return conditions;
    }
    if (type == "PrimaryVariableConstraintDirichlet")
    {
        auto const config_args =
            parsePrimaryVariableConstraintDirichletBoundaryCondition(
                config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                createPrimaryVariableConstraintDirichletBoundaryCondition(
                    config_args, bc_mesh, dof_table, variable_id,
                    *config.component_id, parameters));
        }
        return conditions;
    }
    if (type == "WellboreCompensateNeumann")
    {
        auto const config_args =
            parseWellboreCompensateNeumannBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createWellboreCompensateNeumannBoundaryCondition(
                    config_args, bc_mesh, dof_table, variable_id,
                    *config.component_id, integration_order,
                    shapefunction_order, bulk_mesh.getDimension(), media));
        }
        return conditions;
    }
    if (type == "SolutionDependentDirichlet")
    {
        auto const config_args =
            parseSolutionDependentDirichletBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                ProcessLib::createSolutionDependentDirichletBoundaryCondition(
                    config_args, bc_mesh, dof_table, variable_id,
                    *config.component_id, parameters));
        }
        return conditions;
    }
    if (type == "HCNonAdvectiveFreeComponentFlowBoundary")
    {
        auto const boundary_permeability_name =
            parseHCNonAdvectiveFreeComponentFlowBoundaryCondition(
                config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(
                createHCNonAdvectiveFreeComponentFlowBoundaryCondition(
                    boundary_permeability_name, bc_mesh, dof_table, variable_id,
                    *config.component_id, integration_order, parameters,
                    bulk_mesh.getDimension(), process, shapefunction_order));
        }
        return conditions;
    }
    if (type == "NormalTraction")
    {
        auto const parameter_name = NormalTractionBoundaryCondition::
            parseNormalTractionBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            switch (bulk_mesh.getDimension())
            {
                case 2:
                    conditions.push_back(
                        ProcessLib::NormalTractionBoundaryCondition::
                            createNormalTractionBoundaryCondition<2>(
                                parameter_name, bc_mesh, bulk_mesh, dof_table,
                                variable_id, integration_order,
                                shapefunction_order, parameters));
                    break;
                case 3:
                    conditions.push_back(
                        ProcessLib::NormalTractionBoundaryCondition::
                            createNormalTractionBoundaryCondition<3>(
                                parameter_name, bc_mesh, bulk_mesh, dof_table,
                                variable_id, integration_order,
                                shapefunction_order, parameters));
                    break;
                default:
                    OGS_FATAL(
                        "NormalTractionBoundaryCondition can not be "
                        "instantiated for mesh dimensions other than two or "
                        "three. {}-dimensional mesh was given.",
                        bulk_mesh.getDimension());
            }
        }
        return conditions;
    }
    if (type == "PhaseFieldIrreversibleDamageOracleBoundaryCondition")
    {
        parsePhaseFieldIrreversibleDamageOracleBoundaryCondition(config.config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        conditions.push_back(
            createPhaseFieldIrreversibleDamageOracleBoundaryCondition(
                dof_table, bulk_mesh, variable_id, *config.component_id));
        return conditions;
    }
    if (type == "ReleaseNodalForce")
    {
        auto const decay_parameter_name = parseReleaseNodalForce(config);
        std::vector<std::unique_ptr<BoundaryCondition>> conditions;
        for (auto const& bc_mesh : config.boundary_meshes)
        {
            conditions.push_back(ProcessLib::createReleaseNodalForce(
                bulk_mesh.getDimension(), variable_id, decay_parameter_name,
                config, bc_mesh, dof_table, parameters));
        }
        return conditions;
    }
    OGS_FATAL("Unknown boundary condition type: `{:s}'.", type);
}
 
}  // namespace ProcessLib