Detailed Description

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

Definition at line 39 of file AssemblyMixin.h.

#include <AssemblyMixin.h>

Inheritance diagram for ProcessLib::AssemblyMixinBase:

Collaboration diagram for ProcessLib::AssemblyMixinBase:

Protected Member Functions
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler)

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

void	updateActiveElements (ProcessLib::ProcessVariable const &pv)

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 (GlobalVector const &rhs, NumLib::LocalToGlobalIndexMap const &local_to_global_index_map, SubmeshAssemblyData const &sad)

Protected Attributes
std::vector< SubmeshAssemblyData >	submesh_assembly_data_

std::vector< std::reference_wrapper< MeshLib::PropertyVector< double > > >	residuum_vectors_bulk_

std::size_t	b_submesh_id_ = 0
	ID of the b vector on submeshes, cf. NumLib::VectorProvider.

Assembly::ParallelVectorMatrixAssembler	pvma_

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

Private Member Functions
void	updateActiveElementsImpl (ProcessLib::ProcessVariable const &pv)

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 41 of file AssemblyMixin.h.

    {
        UNINITIALIZED,
        HAS_DEACTIVATED_SUBDOMAINS,
        NO_DEACTIVATED_SUBDOMAINS
    };

Constructor & Destructor Documentation

◆ AssemblyMixinBase()

ProcessLib::AssemblyMixinBase::AssemblyMixinBase ( AbstractJacobianAssembler & jacobian_assembler )

inlineexplicitprotected

Definition at line 49 of file AssemblyMixin.h.

50 : pvma_{jacobian_assembler} {};

ProcessLib::AssemblyMixinBase::pvma_

Assembly::ParallelVectorMatrixAssembler pvma_

Definition AssemblyMixin.h:83

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 172 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 >::assembleGeneric().

◆ copyResiduumVectorsToSubmesh()

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

staticprotected

Definition at line 187 of file AssemblyMixin.cpp.

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

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

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

◆ initializeAssemblyOnSubmeshes()

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

protected

Definition at line 59 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixinBase initializeSubmeshOutput().");
 
    auto const num_residua = residuum_names.size();
 
    if (pvs.size() != num_residua)
    {
        OGS_FATAL(
            "The number of passed residuum names does not match the number "
            "of process variables for process id {}: {} != {}",
            process_id, num_residua, pvs.size());
    }
 
    submesh_assembly_data_.reserve(submeshes.size());
    for (auto& mesh_ref : submeshes)
    {
        auto& mesh = mesh_ref.get();
 
        submesh_assembly_data_.emplace_back(
            mesh, createResiduumVectors(mesh, residuum_names, pvs));
    }
 
    residuum_vectors_bulk_ =
        createResiduumVectors(bulk_mesh, residuum_names, pvs);
}

References DBUG(), OGS_FATAL, residuum_vectors_bulk_, and submesh_assembly_data_.

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

◆ updateActiveElements()

void ProcessLib::AssemblyMixinBase::updateActiveElements ( ProcessLib::ProcessVariable const & pv )

protected

Definition at line 91 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixinBase updateActiveElements().");
 
    if (ids_state_ == ActiveElementIDsState::UNINITIALIZED)
    {
        updateActiveElementsImpl(pv);
        return;
    }
 
    ActiveElementIDsState const new_state =
        pv.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(pv);
}

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

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

◆ updateActiveElementsImpl()

void ProcessLib::AssemblyMixinBase::updateActiveElementsImpl ( ProcessLib::ProcessVariable const & pv )

private

Definition at line 123 of file AssemblyMixin.cpp.

{
    DBUG("AssemblyMixinBase updateActiveElementsImpl().");
 
    auto const& active_element_ids = pv.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_)
        {
            // note: this copies the ID vector!
            sad.active_element_ids = sad.bulk_element_ids;
        }
    }
    else
    {
        // assemble each submesh on the intersection of the "global" active
        // elements and the submesh
        std::unordered_set<std::size_t> active_element_ids_set(
            active_element_ids.begin(), active_element_ids.end());
 
        for (auto& sad : submesh_assembly_data_)
        {
            auto& aeis = sad.active_element_ids;
            auto& beis = sad.bulk_element_ids;
            aeis.clear();
            aeis.reserve(beis.getNumberOfTuples());
 
            for (auto bei : beis)
            {
                if (active_element_ids_set.contains(bei))
                {
                    aeis.push_back(bei);
                }
            }
        }
    }
 
    ids_state_ = new_state;
}