ProcessLib::PythonBoundaryCondition Class Reference

Detailed Description

A boundary condition whose values are computed by a Python script.

Definition at line 43 of file PythonBoundaryCondition.h.

#include <PythonBoundaryCondition.h>

Inheritance diagram for ProcessLib::PythonBoundaryCondition:

Collaboration diagram for ProcessLib::PythonBoundaryCondition:

Public Member Functions
	PythonBoundaryCondition (PythonBoundaryConditionData &&bc_data, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim, bool const flush_stdout)
void	getEssentialBCValues (const double t, const GlobalVector &x, NumLib::IndexValueVector< GlobalIndexType > &bc_values) const override
	Writes the values of essential BCs to bc_values. More...
void	applyNaturalBC (const double t, std::vector< GlobalVector * > const &x, int const process_id, GlobalMatrix &K, GlobalVector &b, GlobalMatrix *Jac) override
Public Member Functions inherited from ProcessLib::BoundaryCondition
virtual void	preTimestep (const double, std::vector< GlobalVector * > const &, int const)
virtual void	postTimestep (const double, std::vector< GlobalVector * > const &, int const)
virtual	~BoundaryCondition ()=default

Private Attributes
PythonBoundaryConditionData	_bc_data
	Auxiliary data. More...
std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_dof_table_boundary
	Local dof table for the boundary mesh. More...
std::vector< std::unique_ptr< GenericNaturalBoundaryConditionLocalAssemblerInterface > >	_local_assemblers
	Local assemblers for all elements of the boundary mesh. More...
bool const	_flush_stdout

Constructor & Destructor Documentation

PythonBoundaryCondition()

ProcessLib::PythonBoundaryCondition::PythonBoundaryCondition	(	PythonBoundaryConditionData &&	bc_data,
		unsigned const	integration_order,
		unsigned const	shapefunction_order,
		unsigned const	global_dim,
		bool const	flush_stdout
	)

Definition at line 25 of file PythonBoundaryCondition.cpp.

    : _bc_data(std::move(bc_data)), _flush_stdout(flush_stdout)
{
    std::vector<MeshLib::Node*> const& bc_nodes =
        _bc_data.boundary_mesh.getNodes();
    MeshLib::MeshSubset bc_mesh_subset(_bc_data.boundary_mesh, bc_nodes);
 
    // Create local DOF table from the bc mesh subset for the given variable and
    // component id.
    _dof_table_boundary = _bc_data.dof_table_bulk.deriveBoundaryConstrainedMap(
        std::move(bc_mesh_subset));
 
    BoundaryConditionAndSourceTerm::createLocalAssemblers<
        PythonBoundaryConditionLocalAssembler>(
        global_dim, _bc_data.boundary_mesh.getElements(), *_dof_table_boundary,
        shapefunction_order, _local_assemblers,
        _bc_data.boundary_mesh.isAxiallySymmetric(), integration_order,
        _bc_data);
}

References _bc_data, _dof_table_boundary, _local_assemblers, ProcessLib::PythonBoundaryConditionData::boundary_mesh, ProcessLib::BoundaryConditionAndSourceTerm::createLocalAssemblers(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), ProcessLib::PythonBoundaryConditionData::dof_table_bulk, MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), and MeshLib::Mesh::isAxiallySymmetric().

Member Function Documentation

applyNaturalBC()

void ProcessLib::PythonBoundaryCondition::applyNaturalBC ( const double  , std::vector< GlobalVector * > const &  , int const  , GlobalMatrix &  , GlobalVector &  , GlobalMatrix *    )

overridevirtual

Applies natural BCs (i.e. non-Dirichlet BCs) to the stiffness matrix K and the vector b.

Reimplemented from ProcessLib::BoundaryCondition.

Definition at line 149 of file PythonBoundaryCondition.cpp.

{
    FlushStdoutGuard guard(_flush_stdout);
 
    try
    {
        GlobalExecutor::executeMemberOnDereferenced(
            &GenericNaturalBoundaryConditionLocalAssemblerInterface::assemble,
            _local_assemblers, *_dof_table_boundary, t, x, process_id, K, b,
            Jac);
    }
    catch (MethodNotOverriddenInDerivedClassException const& /*e*/)
    {
        DBUG("Method `getFlux' not overridden in Python script.");
    }
}

References _dof_table_boundary, _flush_stdout, _local_assemblers, ProcessLib::GenericNaturalBoundaryConditionLocalAssemblerInterface::assemble(), DBUG(), and NumLib::SerialExecutor::executeMemberOnDereferenced().

getEssentialBCValues()

void ProcessLib::PythonBoundaryCondition::getEssentialBCValues ( const double  , const GlobalVector &  , NumLib::IndexValueVector< GlobalIndexType > &    ) const

overridevirtual

Writes the values of essential BCs to bc_values.

Reimplemented from ProcessLib::BoundaryCondition.

Definition at line 50 of file PythonBoundaryCondition.cpp.

{
    FlushStdoutGuard guard(_flush_stdout);
    (void)guard;
 
    auto const nodes = _bc_data.boundary_mesh.getNodes();
 
    auto const& bulk_node_ids_map =
        *_bc_data.boundary_mesh.getProperties().getPropertyVector<std::size_t>(
            "bulk_node_ids", MeshLib::MeshItemType::Node, 1);
 
    bc_values.ids.clear();
    bc_values.values.clear();
 
    bc_values.ids.reserve(_bc_data.boundary_mesh.getNumberOfNodes());
    bc_values.values.reserve(_bc_data.boundary_mesh.getNumberOfNodes());
 
    std::vector<double> primary_variables;
 
    for (auto const* node : _bc_data.boundary_mesh.getNodes())
    {
        auto const boundary_node_id = node->getID();
        auto const bulk_node_id = bulk_node_ids_map[boundary_node_id];
 
        // gather primary variable values
        primary_variables.clear();
        auto const num_var = _dof_table_boundary->getNumberOfVariables();
        for (int var = 0; var < num_var; ++var)
        {
            auto const num_comp =
                _dof_table_boundary->getNumberOfVariableComponents(var);
            for (int comp = 0; comp < num_comp; ++comp)
            {
                MeshLib::Location loc{_bc_data.bulk_mesh_id,
                                      MeshLib::MeshItemType::Node,
                                      bulk_node_id};
                auto const dof_idx =
                    _bc_data.dof_table_bulk.getGlobalIndex(loc, var, comp);
 
                if (dof_idx == NumLib::MeshComponentMap::nop)
                {
                    // TODO extend Python BC to mixed FEM ansatz functions
                    OGS_FATAL(
                        "No d.o.f. found for (node={:d}, var={:d}, comp={:d}). "
                        " That might be due to the use of mixed FEM ansatz "
                        "functions, which is currently not supported by the "
                        "implementation of Python BCs. That excludes, e.g., "
                        "the HM process.",
                        bulk_node_id, var, comp);
                }
 
                primary_variables.push_back(x[dof_idx]);
            }
        }
 
        auto* xs = nodes[boundary_node_id]->getCoords();  // TODO DDC problems?
        auto pair_flag_value = _bc_data.bc_object->getDirichletBCValue(
            t, {xs[0], xs[1], xs[2]}, boundary_node_id, primary_variables);
        if (!_bc_data.bc_object->isOverriddenEssential())
        {
            DBUG(
                "Method `getDirichletBCValue' not overridden in Python "
                "script.");
            return;
        }
 
        if (!pair_flag_value.first)
        {
            continue;
        }
 
        MeshLib::Location l(_bc_data.bulk_mesh_id, MeshLib::MeshItemType::Node,
                            bulk_node_id);
        const auto dof_idx = _bc_data.dof_table_bulk.getGlobalIndex(
            l, _bc_data.global_component_id);
        if (dof_idx == NumLib::MeshComponentMap::nop)
        {
            OGS_FATAL(
                "Logic error. This error should already have occurred while "
                "gathering primary variables. Something nasty is going on!");
        }
 
        // For the DDC approach (e.g. with PETSc option), the negative
        // index of g_idx means that the entry by that index is a ghost
        // one, which should be dropped. Especially for PETSc routines
        // MatZeroRows and MatZeroRowsColumns, which are called to apply
        // the Dirichlet BC, the negative index is not accepted like
        // other matrix or vector PETSc routines. Therefore, the
        // following if-condition is applied.
        if (dof_idx >= 0)
        {
            bc_values.ids.emplace_back(dof_idx);
            bc_values.values.emplace_back(pair_flag_value.second);
        }
    }
}

References _bc_data, _dof_table_boundary, _flush_stdout, ProcessLib::PythonBoundaryConditionData::bc_object, ProcessLib::PythonBoundaryConditionData::boundary_mesh, ProcessLib::PythonBoundaryConditionData::bulk_mesh_id, DBUG(), ProcessLib::PythonBoundaryConditionData::dof_table_bulk, ProcessLib::PythonBoundaryConditionPythonSideInterface::getDirichletBCValue(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), ProcessLib::PythonBoundaryConditionData::global_component_id, NumLib::IndexValueVector< IndexType >::ids, ProcessLib::PythonBoundaryConditionPythonSideInterface::isOverriddenEssential(), MeshLib::Node, NumLib::MeshComponentMap::nop, OGS_FATAL, and NumLib::IndexValueVector< IndexType >::values.

Member Data Documentation

_bc_data

PythonBoundaryConditionData ProcessLib::PythonBoundaryCondition::_bc_data

private

Auxiliary data.

Definition at line 62 of file PythonBoundaryCondition.h.

Referenced by PythonBoundaryCondition(), and getEssentialBCValues().

_dof_table_boundary

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::PythonBoundaryCondition::_dof_table_boundary

private

Local dof table for the boundary mesh.

Definition at line 65 of file PythonBoundaryCondition.h.

Referenced by PythonBoundaryCondition(), applyNaturalBC(), and getEssentialBCValues().

_flush_stdout

bool const ProcessLib::PythonBoundaryCondition::_flush_stdout

private

Whether or not to flush standard output before and after each call to Python code. Ensures right order of output messages and therefore simplifies debugging.

Definition at line 75 of file PythonBoundaryCondition.h.

Referenced by applyNaturalBC(), and getEssentialBCValues().

_local_assemblers

std::vector< std::unique_ptr<GenericNaturalBoundaryConditionLocalAssemblerInterface> > ProcessLib::PythonBoundaryCondition::_local_assemblers

private

Local assemblers for all elements of the boundary mesh.

Definition at line 70 of file PythonBoundaryCondition.h.

Referenced by PythonBoundaryCondition(), and applyNaturalBC().

---

The documentation for this class was generated from the following files:

• ProcessLib/BoundaryConditionAndSourceTerm/Python/PythonBoundaryCondition.h
• ProcessLib/BoundaryConditionAndSourceTerm/Python/PythonBoundaryCondition.cpp