Detailed Description

The SolutionDependentDirichletBoundaryCondition belongs to the Dirichlet-type boundary condition.

This class is a special category of Dirichlet boundary condition, applied in the situation where the value assigned for the boundary condition is dependent on the process solution of the last time step. This particular boundary condition is widely used in the reactive transport problems and has the potential to be used in other processes.

Definition at line 26 of file SolutionDependentDirichletBoundaryCondition.h.

#include <SolutionDependentDirichletBoundaryCondition.h>

Inheritance diagram for ProcessLib::SolutionDependentDirichletBoundaryCondition:

[legend]

Collaboration diagram for ProcessLib::SolutionDependentDirichletBoundaryCondition:

[legend]

Public Member Functions
	SolutionDependentDirichletBoundaryCondition (std::string property_name, ParameterLib::Parameter< double > const &parameter, MeshLib::Mesh const &bc_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, int const variable_id, int const component_id)

void	getEssentialBCValues (double const t, GlobalVector const &x, NumLib::IndexValueVector< GlobalIndexType > &bc_values) const override
	Writes the values of essential BCs to `bc_values`.

void	postTimestep (double const, std::vector< GlobalVector * > const &x, int const process_id) override

Public Member Functions inherited from ProcessLib::BoundaryCondition
virtual void	applyNaturalBC (const double, std::vector< GlobalVector * > const &, int const, GlobalMatrix &, GlobalVector &, GlobalMatrix *)

virtual void	preTimestep (const double, std::vector< GlobalVector * > const &, int const)

virtual	~BoundaryCondition ()=default

Private Attributes
MeshLib::Mesh const &	_bc_mesh

int const	_variable_id

int const	_component_id

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

std::unique_ptr< ParameterLib::MeshNodeParameter< double > >	_parameter

MeshLib::PropertyVector< double > *	_solution_dependent_bc

Constructor & Destructor Documentation

◆ SolutionDependentDirichletBoundaryCondition()

ProcessLib::SolutionDependentDirichletBoundaryCondition::SolutionDependentDirichletBoundaryCondition	(	std::string	property_name,
		ParameterLib::Parameter< double > const &	parameter,
		MeshLib::Mesh const &	bc_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		int const	variable_id,
		int const	component_id )

Definition at line 26 of file SolutionDependentDirichletBoundaryCondition.cpp.

    : _bc_mesh(bc_mesh), _variable_id(variable_id), _component_id(component_id)
{
    checkParametersOfDirichletBoundaryCondition(_bc_mesh, dof_table_bulk,
                                                _variable_id, _component_id);
 
    std::vector<MeshLib::Node*> const& bc_nodes = bc_mesh.getNodes();
    MeshLib::MeshSubset bc_mesh_subset(_bc_mesh, bc_nodes);
 
    // Create local DOF table from the BC mesh subset for the given variable
    // and component id.
    _dof_table_boundary = dof_table_bulk.deriveBoundaryConstrainedMap(
        variable_id, {component_id}, std::move(bc_mesh_subset));
 
    if (bc_mesh.getProperties().existsPropertyVector<double>(property_name))
    {
        OGS_FATAL(
            "Found mesh property '{:s}' in the mesh '{:s}' which is for "
            "boundary assignment. This mesh property is the built-in property "
            "of the class SolutionDependentDirichletBoundaryCondition.",
            property_name, bc_mesh.getName());
    }
 
    _solution_dependent_bc = MeshLib::getOrCreateMeshProperty<double>(
        const_cast<MeshLib::Mesh&>(bc_mesh), property_name,
        MeshLib::MeshItemType::Node, 1);
    _solution_dependent_bc->resize(bc_mesh.getNumberOfNodes());
 
    ParameterLib::SpatialPosition pos;
 
    auto const& nodes = bc_mesh.getNodes();
    for (std::size_t i = 0; i < _solution_dependent_bc->size(); ++i)
    {
        auto const id = nodes[i]->getID();
        pos.setNodeID(id);
        (*_solution_dependent_bc)[i] = parameter(0, pos)[0];
    }
 
    _parameter = std::make_unique<ParameterLib::MeshNodeParameter<double>>(
        property_name, bc_mesh, *_solution_dependent_bc);
}

References _bc_mesh, _component_id, _dof_table_boundary, _parameter, _solution_dependent_bc, _variable_id, ProcessLib::checkParametersOfDirichletBoundaryCondition(), NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::Node, OGS_FATAL, ParameterLib::SpatialPosition::setNodeID(), and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Member Function Documentation

◆ getEssentialBCValues()

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

overridevirtual

Writes the values of essential BCs to bc_values.

Reimplemented from ProcessLib::BoundaryCondition.

Definition at line 74 of file SolutionDependentDirichletBoundaryCondition.cpp.

{
    getEssentialBCValuesLocal(*_parameter, _bc_mesh, *_dof_table_boundary,
                              _variable_id, _component_id, t, x, bc_values);
}

References _bc_mesh, _component_id, _dof_table_boundary, _parameter, _variable_id, and ProcessLib::getEssentialBCValuesLocal().

◆ postTimestep()

void ProcessLib::SolutionDependentDirichletBoundaryCondition::postTimestep	(	double const	,
		std::vector< GlobalVector * > const &	x,
		int const	process_id )

overridevirtual

Renchao: The original idea to place the update of the boundary condition value at the preTimestep stage. The update could be achieved within the class function "Process::preTimestep". Whereas, I find it not doable to implement in this way. The class function "Process::preTimestep" is called in a row by the functions "preTimestepForAllProcesses" and "TimeLoop::outputSolutions". These two functions are called when initializing and subsequently looping over the "TimeLoop". Actually, it is not intended to make the boundary condition value updated in the first loop. Instead, the update is intended to start from the second loop. For these two reasons, I think it more proper to do the implementation at the postTimestep stage.

Reimplemented from ProcessLib::BoundaryCondition.

Definition at line 82 of file SolutionDependentDirichletBoundaryCondition.cpp.

{
    auto const& nodes = _bc_mesh.getNodes();
    for (std::size_t i = 0; i < _solution_dependent_bc->size(); ++i)
    {
        auto const id = nodes[i]->getID();
        auto const global_index = _dof_table_boundary->getGlobalIndex(
            {_bc_mesh.getID(), MeshLib::MeshItemType::Node, id}, _variable_id,
            _component_id);
 
        assert(global_index >= 0);
        (*_solution_dependent_bc)[i] = x[process_id]->get(global_index);
    }
}