PythonBoundaryCondition.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 <string>
 
#include "NumLib/DOF/LocalToGlobalIndexMap.h"
#include "NumLib/IndexValueVector.h"
#include "ProcessLib/BoundaryConditionAndSourceTerm/BoundaryCondition.h"
#include "PythonBoundaryConditionLocalAssemblerInterface.h"
#include "PythonBoundaryConditionPythonSideInterface.h"
#include "Utils/BcOrStData.h"
 
namespace ProcessLib
{
class ProcessVariable;

struct MethodNotOverriddenInDerivedClassException
{
};
 
struct PythonBoundaryConditionConfig
{
    std::string bc_object;
    bool flush_stdout;
};
 
struct PythonBcData final
    : ProcessLib::BoundaryConditionAndSourceTerm::Python::BcOrStData<
          PythonBoundaryConditionPythonSideInterface>
{
    ProcessLib::BoundaryConditionAndSourceTerm::Python::FlagAndFluxAndDFlux
    getFlagAndFluxAndDFlux(double const t, std::array<double, 3> const coords,
                           std::vector<double> const& prim_vars_data) const
    {
        auto [flag, flux, dFlux] =
            bc_or_st_object->getFlux(t, coords, prim_vars_data);
 
        if (!bc_or_st_object->isOverriddenNatural())
        {
            // getFlux() is not overridden in Python, so we can skip the
            // whole BC assembly (i.e., for all boundary elements).
            throw MethodNotOverriddenInDerivedClassException{};
        }
 
        return {flag, flux, std::move(dFlux)};
    }
};

class PythonBoundaryCondition final : public BoundaryCondition
{
public:
    PythonBoundaryCondition(
        PythonBcData&& bc_data,
        unsigned const integration_order,
        bool const flush_stdout,
        unsigned const bulk_mesh_dimension,
        NumLib::LocalToGlobalIndexMap const& dof_table_bulk);
 
    void getEssentialBCValues(
        const double t, const GlobalVector& x,
        NumLib::IndexValueVector<GlobalIndexType>& bc_values) const override;
 
    void applyNaturalBC(const double t, std::vector<GlobalVector*> const& x,
                        int const process_id, GlobalMatrix* K, GlobalVector& b,
                        GlobalMatrix* Jac) override;
 
private:
    void collectPrimaryVariables(std::vector<double>& primary_variables,
                                 MeshLib::Node const& boundary_node,
                                 GlobalVector const& x) const;

    GlobalIndexType getDofIdx(std::size_t const boundary_node_id) const;

    GlobalIndexType getDofIdx(std::size_t const boundary_node_id, int const var,
                              int const comp) const;

    double interpolateToHigherOrderNode(
        GlobalVector const& x, int const var, int const comp,
        MeshLib::Node const& boundary_node) const;

    PythonBcData _bc_data;

    std::unique_ptr<NumLib::LocalToGlobalIndexMap> _dof_table_boundary;

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

    bool const _flush_stdout;
};
 
PythonBoundaryConditionConfig parsePythonBoundaryCondition(
    BaseLib::ConfigTree const& config);

std::unique_ptr<PythonBoundaryCondition> createPythonBoundaryCondition(
    PythonBoundaryConditionConfig const& config,
    MeshLib::Mesh const& boundary_mesh,
    NumLib::LocalToGlobalIndexMap const& dof_table_bulk,
    MeshLib::Mesh const& bulk_mesh, int const variable_id,
    int const component_id, unsigned const integration_order,
    unsigned const shapefunction_order,
    std::vector<std::reference_wrapper<ProcessVariable>> const&
        all_process_variables_for_this_process);
 
}  // namespace ProcessLib