ProcessLib::AssemblyMixin< Process > Class Template Reference

Detailed Description

template<typename Process>
class ProcessLib::AssemblyMixin< Process >

A mixin providing assembly functionality to a specific Process.

The process must be derived from this class (CRTP).

Definition at line 101 of file AssemblyMixin.h.

#include <AssemblyMixin.h>

Inheritance diagram for ProcessLib::AssemblyMixin< Process >:

Collaboration diagram for ProcessLib::AssemblyMixin< Process >:

Public Member Functions
void	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names)
void	updateActiveElements ()
void	assemble (double const t, double const dt, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > const &, int const process_id, GlobalMatrix &, GlobalMatrix &, GlobalVector &)
void	assembleWithJacobian (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac)

Private Member Functions
Process &	derived ()
Process const &	derived () const
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler)
Private Member Functions inherited from ProcessLib::AssemblyMixinBase
	AssemblyMixinBase (AbstractJacobianAssembler &jacobian_assembler)
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)

Private Attributes
friend	Process
Private Attributes inherited from ProcessLib::AssemblyMixinBase
std::vector< SubmeshAssemblyData >	submesh_assembly_data_
std::vector< 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_

Additional Inherited Members
Static Private Member Functions inherited from ProcessLib::AssemblyMixinBase
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, SubmeshAssemblyData const &sad)

Member Function Documentation

assemble()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::assemble ( double const t, double const dt, std::vector< GlobalVector * > const & , std::vector< GlobalVector * > const & , int const process_id, GlobalMatrix & , GlobalMatrix & , GlobalVector &  )

inline

Implementation similar to assembleWithJacobian calling Assembly::ParallelVectorMatrixAssembler::assemble function. Residuum must be correctly computed.

Definition at line 145 of file AssemblyMixin.h.

    {
        DBUG("AssemblyMixin assemble(t={}, dt={}, process_id={}).", t, dt,
             process_id);

        OGS_FATAL("AssemblyMixin for Picard scheme is not yet implemented.");
    }

References DBUG(), and OGS_FATAL.

assembleWithJacobian()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::assembleWithJacobian ( double const t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id, GlobalVector & b, GlobalMatrix & Jac )

inline

Definition at line 160 of file AssemblyMixin.h.

    {
        DBUG("AssemblyMixin assembleWithJacobian(t={}, dt={}, process_id={}).",
             t, dt, process_id);
 
        std::vector<NumLib::LocalToGlobalIndexMap const*> const dof_tables =
            derived().getDOFTables(x.size());
 
        auto const& loc_asms = derived().local_assemblers_;
 
        std::exception_ptr exception = nullptr;
        if (!submesh_assembly_data_.empty())
        {
            auto& b_submesh = NumLib::GlobalVectorProvider::provider.getVector(
                b, b_submesh_id_);
 
            for (auto const& sad : submesh_assembly_data_)
            {
                b_submesh.setZero();
 
                try
                {
                    pvma_.assembleWithJacobian(loc_asms, sad.active_element_ids,
                                               dof_tables, t, dt, x, x_prev,
                                               process_id, b_submesh, Jac);
                }
                catch (NumLib::AssemblyException const&)
                {
                    exception = std::current_exception();
                }
 
                MathLib::LinAlg::axpy(b, 1.0, b_submesh);
 
                AssemblyMixinBase::copyResiduumVectorsToSubmesh(
                    process_id, b_submesh, *(dof_tables[process_id]), sad);
            }
 
            NumLib::GlobalVectorProvider::provider.releaseVector(b_submesh);
        }
        else
        {
            try
            {
                pvma_.assembleWithJacobian(
                    loc_asms, derived().getActiveElementIDs(), dof_tables, t,
                    dt, x, x_prev, process_id, b, Jac);
            }
            catch (NumLib::AssemblyException const&)
            {
                exception = std::current_exception();
            }
        }
 
        MathLib::LinAlg::finalizeAssembly(b);
        MathLib::LinAlg::finalizeAssembly(Jac);
 
        if (BaseLib::MPI::anyOf(exception != nullptr))
        {
            if (exception)  // Only the rank with the exception rethrows...
            {
                std::rethrow_exception(exception);
            }
            // ... but all ranks quit.
            return;
        }
 
        AssemblyMixinBase::copyResiduumVectorsToBulkMesh(
            b, *(dof_tables[process_id]), residuum_vectors_bulk_[process_id]);
    }

References BaseLib::MPI::anyOf(), MathLib::LinAlg::axpy(), ProcessLib::AssemblyMixinBase::b_submesh_id_, ProcessLib::AssemblyMixinBase::copyResiduumVectorsToBulkMesh(), ProcessLib::AssemblyMixinBase::copyResiduumVectorsToSubmesh(), DBUG(), derived(), MathLib::LinAlg::finalizeAssembly(), ProcessLib::Process::getDOFTables(), NumLib::GlobalVectorProvider::provider, ProcessLib::AssemblyMixinBase::pvma_, ProcessLib::AssemblyMixinBase::residuum_vectors_bulk_, and ProcessLib::AssemblyMixinBase::submesh_assembly_data_.

AssemblyMixinBase()

template<typename Process>

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

inlineexplicitprivate

Definition at line 53 of file AssemblyMixin.h.

        : pvma_{jacobian_assembler} {};

derived() [1/2]

template<typename Process>

Process & ProcessLib::AssemblyMixin< Process >::derived ( )

inlineprivate

Definition at line 235 of file AssemblyMixin.h.

{ return static_cast<Process&>(*this); }

References Process.

Referenced by assembleWithJacobian(), initializeAssemblyOnSubmeshes(), and updateActiveElements().

derived() [2/2]

template<typename Process>

Process const & ProcessLib::AssemblyMixin< Process >::derived ( ) const

inlineprivate

Definition at line 236 of file AssemblyMixin.h.

    {
        return static_cast<Process const&>(*this);
    }

References Process.

initializeAssemblyOnSubmeshes()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes ( std::vector< std::reference_wrapper< MeshLib::Mesh > > const & submeshes, std::vector< std::vector< std::string > > const & residuum_names )

inline

Specifies that the assembly of the process should take place on the passed submeshes.

Note

This method must be called at most once.

Attention

The passed submeshes must be non-overlapping and must cover the entire simulation domain. The caller is responsible to meet this requirement.

The order of the passed residuum_names matters and must match the order of the residuum vectors in the process. Otherwise residuum output on submeshes will be wrong.

Note

As of January 2023 assembly on submeshes has neither been tested with domain decomposition, nor with domain deactivation nor staggered coupling. Use at your own risk in these cases.

Todo

Implement and test with domain decomposition, domain deactivation and staggered coupling.

Definition at line 130 of file AssemblyMixin.h.

    {
        AssemblyMixinBase::initializeAssemblyOnSubmeshes(
            derived().getMesh(), submeshes, residuum_names,
            derived().getProcessVariables());
    }

References derived(), and ProcessLib::AssemblyMixinBase::initializeAssemblyOnSubmeshes().

updateActiveElements()

template<typename Process>

void ProcessLib::AssemblyMixin< Process >::updateActiveElements ( )

inline

Definition at line 139 of file AssemblyMixin.h.

    {
        AssemblyMixinBase::updateActiveElements(derived());
    }

References derived(), and ProcessLib::AssemblyMixinBase::updateActiveElements().

Member Data Documentation

Process

template<typename Process>

friend ProcessLib::AssemblyMixin< Process >::Process

private

Definition at line 106 of file AssemblyMixin.h.

Referenced by derived(), and derived().

---

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

• AssemblyMixin.h