Detailed Description

Provides basic functionality for the AssemblyMixin that does not require template parameters.

Definition at line 22 of file AssemblyMixin.h.

#include <AssemblyMixin.h>

Inheritance diagram for ProcessLib::AssemblyMixinBase:

Collaboration diagram for ProcessLib::AssemblyMixinBase:

Protected Member Functions
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler, bool const is_linear, bool const use_monolithic_scheme)
void	initializeAssemblyOnSubmeshes (MeshLib::Mesh &bulk_mesh, std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &pvs)
void	updateActiveElements (ProcessLib::Process const &process)
bool	isLinear () const

Static Protected Member Functions
static void	copyResiduumVectorsToBulkMesh (GlobalVector const &rhs, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, std::vector< std::reference_wrapper< MeshLib::PropertyVector< double > > > residuum_vectors)
static void	copyResiduumVectorsToSubmesh (int const process_id, GlobalVector const &rhs, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, ProcessLib::Assembly::SubmeshAssemblyData const &sad)

Protected Attributes
std::vector< ProcessLib::Assembly::SubmeshAssemblyData >	submesh_assembly_data_
	SubmeshAssemblyData for each submesh.
std::vector< AssembledMatrixCache >	submesh_matrix_cache_
	AssembledMatrixCache for each submesh.
std::optional< ProcessLib::Assembly::BulkMeshAssemblyData >	bulk_mesh_assembly_data_
	Empty if submesh assembly is used.
AssembledMatrixCache	bulk_mesh_matrix_cache_
Assembly::ParallelVectorMatrixAssembler	pvma_
bool	is_linear_
std::optional< NumLib::NonlinearSolverTag >	last_assembly_was_

Private Types
enum class	ActiveElementIDsState { UNINITIALIZED , HAS_DEACTIVATED_SUBDOMAINS , NO_DEACTIVATED_SUBDOMAINS }

Private Member Functions
void	updateActiveElementsImpl (Process const &process)

Private Attributes
ActiveElementIDsState	ids_state_ = ActiveElementIDsState::UNINITIALIZED

Member Enumeration Documentation

◆ ActiveElementIDsState

enum class ProcessLib::AssemblyMixinBase::ActiveElementIDsState

strongprivate

Enumerator
UNINITIALIZED
HAS_DEACTIVATED_SUBDOMAINS
NO_DEACTIVATED_SUBDOMAINS

Definition at line 24 of file AssemblyMixin.h.

    {
        UNINITIALIZED,
        HAS_DEACTIVATED_SUBDOMAINS,
        NO_DEACTIVATED_SUBDOMAINS
    };

Constructor & Destructor Documentation

◆ AssemblyMixinBase()

ProcessLib::AssemblyMixinBase::AssemblyMixinBase	(	AbstractJacobianAssembler &	jacobian_assembler,
		bool const	is_linear,
		bool const	use_monolithic_scheme )

explicitprotected

Definition at line 97 of file AssemblyMixin.cpp.

    : pvma_{jacobian_assembler}, is_linear_{is_linear}
{
    if (is_linear && !use_monolithic_scheme)
    {
        OGS_FATAL(
            "You requested to assemble only once in combination with staggered "
            "coupling. This use case is not yet implemented.");
    }
 
    if (is_linear_)
    {
        WARN(
            "You specified that the process simulated by OGS is linear. With "
            "this optimization, the system is assembled only once, and the "
            "non-linear solver performs a single iteration per time step. No "
            "non-linearities will be resolved, and OGS will not detect whether "
            "any exist. It is your responsibility to ensure that the assembled "
            "systems are indeed linear; there is no safety net.\n"
            "\n"
            "Be aware that non-linearities may arise in subtle ways. For "
            "example, in an HT problem with a steady-state velocity field, if "
            "the initial pressure field does not match the steady-state "
            "condition (e.g., initialized to zero), then the steady-state "
            "velocity field only emerges during the first iteration—making the "
            "system effectively non-linear under this optimization.");
    }
}

References is_linear_, OGS_FATAL, pvma_, and WARN().

Member Function Documentation

◆ copyResiduumVectorsToBulkMesh()

void ProcessLib::AssemblyMixinBase::copyResiduumVectorsToBulkMesh	(	GlobalVector const &	rhs,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		std::vector< std::reference_wrapper< MeshLib::PropertyVector< double > > >	residuum_vectors )

staticprotected

Definition at line 235 of file AssemblyMixin.cpp.

{
    for (std::size_t variable_id = 0; variable_id < residuum_vectors.size();
         ++variable_id)
    {
        transformVariableFromGlobalVector(
            rhs, variable_id, local_to_global_index_map,
            residuum_vectors[variable_id].get(), std::negate<double>());
    }
}

Referenced by ProcessLib::AssemblyMixin< Process >::assemble(), and ProcessLib::AssemblyMixin< Process >::assembleWithJacobian().

◆ copyResiduumVectorsToSubmesh()

void ProcessLib::AssemblyMixinBase::copyResiduumVectorsToSubmesh	(	int const	process_id,
		GlobalVector const &	rhs,
		NumLib::LocalToGlobalIndexMap const &	local_to_global_index_map,
		ProcessLib::Assembly::SubmeshAssemblyData const &	sad )

staticprotected

Definition at line 250 of file AssemblyMixin.cpp.

{
    auto const& residuum_vectors = sad.residuum_vectors[process_id];
    for (std::size_t variable_id = 0; variable_id < residuum_vectors.size();
         ++variable_id)
    {
        transformVariableFromGlobalVector(
            rhs, variable_id, local_to_global_index_map,
            residuum_vectors[variable_id].get(),
            std::span<std::size_t const>{sad.bulk_node_ids},
            std::negate<double>());
    }
}

References ProcessLib::Assembly::SubmeshAssemblyData::bulk_node_ids, and ProcessLib::Assembly::CommonAssemblyData::residuum_vectors.

Referenced by ProcessLib::AssemblyMixin< Process >::assembleOnSubmeshes(), and ProcessLib::AssemblyMixin< Process >::assembleWithJacobianOnSubmeshes().

◆ initializeAssemblyOnSubmeshes()

void ProcessLib::AssemblyMixinBase::initializeAssemblyOnSubmeshes	(	MeshLib::Mesh &	bulk_mesh,
		std::vector< std::reference_wrapper< MeshLib::Mesh > > const &	submeshes,
		std::vector< std::vector< std::string > > const &	residuum_names,
		std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &	pvs )

protected

Definition at line 129 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixinBase initializeSubmeshOutput().");
 
    auto const num_submeshes = submeshes.size();
 
    if (num_submeshes == 0)
    {
        bulk_mesh_assembly_data_.emplace(
            createResiduumVectors(bulk_mesh, residuum_names, pvs));
        return;
    }
 
    submesh_assembly_data_.reserve(num_submeshes);
    for (auto& submesh_ref : submeshes)
    {
        auto& submesh = submesh_ref.get();
 
        submesh_assembly_data_.emplace_back(
            submesh, createResiduumVectors(submesh, residuum_names, pvs));
    }
 
    submesh_matrix_cache_.resize(num_submeshes);
}

References bulk_mesh_assembly_data_, DBUG(), submesh_assembly_data_, and submesh_matrix_cache_.

Referenced by ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes().

◆ isLinear()

bool ProcessLib::AssemblyMixinBase::isLinear ( ) const

inlineprotected

Definition at line 45 of file AssemblyMixin.h.

45{ return is_linear_; }

References is_linear_.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::isLinear(), ProcessLib::HeatConduction::HeatConductionProcess::isLinear(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::isLinear().

◆ updateActiveElements()

void ProcessLib::AssemblyMixinBase::updateActiveElements ( ProcessLib::Process const & process )

protected

Definition at line 159 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixin updateActiveElements().");
 
    if (ids_state_ == ActiveElementIDsState::UNINITIALIZED)
    {
        updateActiveElementsImpl(process);
        return;
    }
 
    ActiveElementIDsState const new_state =
        process.getActiveElementIDs().empty()
            ? ActiveElementIDsState::NO_DEACTIVATED_SUBDOMAINS
            : ActiveElementIDsState::HAS_DEACTIVATED_SUBDOMAINS;
 
    if (ids_state_ == ActiveElementIDsState::NO_DEACTIVATED_SUBDOMAINS &&
        new_state == ActiveElementIDsState::NO_DEACTIVATED_SUBDOMAINS)
    {
        // no update necessary
        return;
    }
 
    // updating the active elements is necessary in all remaining cases, because
    // of the following transitions between old and new states (deactivated
    // subdomains present? yes/no; old state -> new state):
    // * no -> yes - now there are deactivated subdomains
    // * yes -> no - no deactivated subdomains anymore
    // * yes -> yes - deactivated subdomains might have changed
    updateActiveElementsImpl(process);
}

References DBUG(), ProcessLib::Process::getActiveElementIDs(), HAS_DEACTIVATED_SUBDOMAINS, ids_state_, NO_DEACTIVATED_SUBDOMAINS, UNINITIALIZED, and updateActiveElementsImpl().

Referenced by ProcessLib::AssemblyMixin< Process >::updateActiveElements().

◆ updateActiveElementsImpl()

void ProcessLib::AssemblyMixinBase::updateActiveElementsImpl ( Process const & process )

private

Definition at line 190 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixinBase updateActiveElementsImpl().");
 
    auto const& active_element_ids = process.getActiveElementIDs();
 
    ActiveElementIDsState const new_state =
        active_element_ids.empty()
            ? ActiveElementIDsState::NO_DEACTIVATED_SUBDOMAINS
            : ActiveElementIDsState::HAS_DEACTIVATED_SUBDOMAINS;
 
    if (new_state == ActiveElementIDsState::NO_DEACTIVATED_SUBDOMAINS)
    {
        // no deactivated subdomains, assemble on all elements as specified
        // in the bulk_element_ids of the submeshes
        for (auto& sad : submesh_assembly_data_)
        {
            sad.setAllElementsActive();
        }
        if (bulk_mesh_assembly_data_)
        {
            bulk_mesh_assembly_data_->setAllElementsActive();
        }
    }
    else
    {
        auto active_element_ids_copy{active_element_ids};
        // assemble each submesh on the intersection of the "global" active
        // elements and the submesh
        ranges::sort(active_element_ids_copy);
 
        for (auto& sad : submesh_assembly_data_)
        {
            sad.setElementSelectionActive(active_element_ids_copy);
        }
        if (bulk_mesh_assembly_data_)
        {
            bulk_mesh_assembly_data_->setElementSelectionActive(
                active_element_ids_copy);
        }
    }
 
    ids_state_ = new_state;
}