ProcessLib::PythonBoundaryCondition Class Reference

Detailed Description

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

Definition at line 58 of file PythonBoundaryCondition.h.

#include <PythonBoundaryCondition.h>

Inheritance diagram for ProcessLib::PythonBoundaryCondition:

Collaboration diagram for ProcessLib::PythonBoundaryCondition:

Public Member Functions
	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
	Writes the values of essential BCs to bc_values.
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 Member Functions
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

Private Attributes
PythonBcData	_bc_data
	Auxiliary data used by the local assemblers.
std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_dof_table_boundary
	Local dof table for the boundary mesh.
std::vector< std::unique_ptr< PythonBoundaryConditionLocalAssemblerInterface > >	_local_assemblers
	Local assemblers for all elements of the boundary mesh.
bool const	_flush_stdout

Constructor & Destructor Documentation

PythonBoundaryCondition()

ProcessLib::PythonBoundaryCondition::PythonBoundaryCondition	(	PythonBcData &&	bc_data,
		unsigned const	integration_order,
		bool const	flush_stdout,
		unsigned const	bulk_mesh_dimension,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk )

Definition at line 64 of file PythonBoundaryCondition.cpp.

    : _bc_data(std::move(bc_data)), _flush_stdout(flush_stdout)
{
    checkConsistency(dof_table_bulk,
                     _bc_data.all_process_variables_for_this_process);
 
    std::vector<MeshLib::Node*> const& bc_nodes =
        _bc_data.bc_or_st_mesh.getNodes();
    MeshLib::MeshSubset bc_mesh_subset(_bc_data.bc_or_st_mesh, bc_nodes);
 
    _dof_table_boundary =
        dof_table_bulk.deriveBoundaryConstrainedMap(std::move(bc_mesh_subset));
 
    BoundaryConditionAndSourceTerm::createLocalAssemblersPython<
        PythonBoundaryConditionLocalAssembler>(
        bulk_mesh_dimension, _bc_data.bc_or_st_mesh.getElements(),
        *_dof_table_boundary, _local_assemblers,
        NumLib::IntegrationOrder{integration_order},
        _bc_data.bc_or_st_mesh.isAxiallySymmetric(), _bc_data);
}

References _bc_data, _dof_table_boundary, _flush_stdout, _local_assemblers, ProcessLib::BoundaryConditionAndSourceTerm::createLocalAssemblersPython(), and NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap().

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 239 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.");
    }
    catch (pybind11::error_already_set const& e)
    {
        OGS_FATAL("Error evaluating natural BC in Python: {}", e.what());
    }
}

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

collectPrimaryVariables()

void ProcessLib::PythonBoundaryCondition::collectPrimaryVariables ( std::vector< double > & primary_variables, MeshLib::Node const & boundary_node, GlobalVector const & x ) const

private

Collects primary variables at the passed node from the passed GlobalVector to primary_variables.

Primary variables at higher order nodes are interpolated from base nodes if necessary, e.g., for Taylor-Hood elements.

Postcondition

primary_variables will contain the value of each component of each primary variable. Their order is determined by the d.o.f. table.

Definition at line 173 of file PythonBoundaryCondition.cpp.

{
    primary_variables.clear();
    auto const num_var = _dof_table_boundary->getNumberOfVariables();
    auto const boundary_node_id = boundary_node.getID();
 
    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)
        {
            auto const dof_idx = getDofIdx(boundary_node_id, var, comp);
 
            double const pv_value =
                dof_idx != NumLib::MeshComponentMap::nop
                    ? x[dof_idx]
                    : interpolateToHigherOrderNode(x, var, comp, boundary_node);
 
            primary_variables.push_back(pv_value);
        }
    }
}

References _dof_table_boundary, getDofIdx(), MathLib::Point3dWithID::getID(), interpolateToHigherOrderNode(), and NumLib::MeshComponentMap::nop.

Referenced by getEssentialBCValues().

getDofIdx() [1/2]

GlobalIndexType ProcessLib::PythonBoundaryCondition::getDofIdx ( std::size_t const boundary_node_id ) const

private

Get the d.o.f. index at the given boundary_node_id for this BC's variable and component.

Definition at line 156 of file PythonBoundaryCondition.cpp.

{
    MeshLib::Location const loc{_bc_data.bc_or_st_mesh.getID(),
                                MeshLib::MeshItemType::Node, boundary_node_id};
    return _dof_table_boundary->getGlobalIndex(loc,
                                               _bc_data.global_component_id);
}

References _bc_data, _dof_table_boundary, and MeshLib::Node.

Referenced by collectPrimaryVariables(), and getEssentialBCValues().

getDofIdx() [2/2]

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

private

Get the d.o.f. index at the given boundary_node_id for the given variable and component.

Definition at line 165 of file PythonBoundaryCondition.cpp.

{
    MeshLib::Location const loc{_bc_data.bc_or_st_mesh.getID(),
                                MeshLib::MeshItemType::Node, boundary_node_id};
    return _dof_table_boundary->getGlobalIndex(loc, var, comp);
}

References _bc_data, _dof_table_boundary, and MeshLib::Node.

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 88 of file PythonBoundaryCondition.cpp.

{
    FlushStdoutGuard guard(_flush_stdout);
    (void)guard;
 
    auto const& boundary_mesh = _bc_data.bc_or_st_mesh;
    auto const& boundary_nodes = boundary_mesh.getNodes();
    auto const* bc_object = _bc_data.bc_or_st_object;
 
    initBCValues(bc_values, boundary_nodes.size());
 
    std::vector<double> primary_variables;
 
    try
    {
        for (auto const* boundary_node : boundary_nodes)
        {
            auto const boundary_node_id = boundary_node->getID();
            auto const dof_idx = getDofIdx(boundary_node_id);
 
            if (dof_idx == NumLib::MeshComponentMap::nop)
            {
                // This d.o.f. has not been found. This can be the case, e.g.,
                // for Taylor-Hood elements, where the lower order field has no
                // d.o.f. on higher order nodes.
                continue;
            }
 
            if (dof_idx < 0)
            {
                // For the DDC approach (e.g. with PETSc option) a negative
                // index means that this entry is a ghost entry and should be
                // dropped.
                continue;
            }
 
            collectPrimaryVariables(primary_variables, *boundary_node, x);
 
            auto const [apply_bc, bc_value] = bc_object->getDirichletBCValue(
                t,
                {(*boundary_node)[0], (*boundary_node)[1], (*boundary_node)[2]},
                boundary_node_id, primary_variables);
 
            if (!bc_object->isOverriddenEssential())
            {
                DBUG(
                    "Method `getDirichletBCValue' not overridden in Python "
                    "script.");
                return;
            }
 
            if (!apply_bc)
            {
                continue;
            }
 
            bc_values.ids.emplace_back(dof_idx);
            bc_values.values.emplace_back(bc_value);
        }
    }
    catch (pybind11::error_already_set const& e)
    {
        OGS_FATAL("Error evaluating Dirichlet BC in Python: {}", e.what());
    }
}

References _bc_data, _flush_stdout, collectPrimaryVariables(), DBUG(), getDofIdx(), NumLib::IndexValueVector< IndexType >::ids, NumLib::MeshComponentMap::nop, OGS_FATAL, and NumLib::IndexValueVector< IndexType >::values.

interpolateToHigherOrderNode()

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

private

Interpolates the given component of the given variable to the given boundary_node.

Definition at line 199 of file PythonBoundaryCondition.cpp.

{
    auto const& boundary_elements =
        _bc_data.bc_or_st_mesh.getElementsConnectedToNode(
            boundary_node.getID());
 
    if (boundary_elements.size() != 1)
    {
        DBUG(
            "Boundary node {} is associated with {} elements in the boundary "
            "mesh.",
            boundary_node.getID(),
            boundary_elements.size());
    }
 
    // Interpolations on all associated elements should return the same. Just
    // pick any of them.
    auto const& boundary_element = *boundary_elements.front();
 
    assert(boundary_element.getNumberOfBaseNodes() <
               boundary_element.getNumberOfNodes() &&
           "We expect that the boundary element is a higher order element. "
           "Otherwise no interpolation should take place.");
 
    // Search local node id
    auto const local_node_id_within_boundary_element =
        getNodeIDinElement(boundary_element, &boundary_node);
 
    auto const boundary_element_id = boundary_element.getID();
 
    // Assumption: all boundary elements have a local assembler (in the same
    // order)
    auto const& loc_asm = *_local_assemblers[boundary_element_id];
 
    return loc_asm.interpolate(local_node_id_within_boundary_element,
                               *_dof_table_boundary, x, var, comp);
}

References _bc_data, _dof_table_boundary, _local_assemblers, DBUG(), and MathLib::Point3dWithID::getID().

Referenced by collectPrimaryVariables().

Member Data Documentation

_bc_data

PythonBcData ProcessLib::PythonBoundaryCondition::_bc_data

private

Auxiliary data used by the local assemblers.

Definition at line 105 of file PythonBoundaryCondition.h.

Referenced by PythonBoundaryCondition(), getDofIdx(), getDofIdx(), getEssentialBCValues(), and interpolateToHigherOrderNode().

_dof_table_boundary

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

private

Local dof table for the boundary mesh.

Definition at line 108 of file PythonBoundaryCondition.h.

Referenced by PythonBoundaryCondition(), applyNaturalBC(), collectPrimaryVariables(), getDofIdx(), getDofIdx(), and interpolateToHigherOrderNode().

_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 117 of file PythonBoundaryCondition.h.

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

_local_assemblers

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

private

Local assemblers for all elements of the boundary mesh.

Definition at line 112 of file PythonBoundaryCondition.h.

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

---

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

• PythonBoundaryCondition.h
• PythonBoundaryCondition.cpp