ProcessLib::AssembledMatrixCache Struct Reference

Detailed Description

Definition at line 27 of file AssembledMatrixCache.h.

#include <AssembledMatrixCache.h>

Public Member Functions
	AssembledMatrixCache (bool const is_linear, bool const use_monolithic_scheme)
template<typename VectorOfLocalAssemblers>
void	assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix *const M, GlobalMatrix *const K, GlobalVector *const b, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, VectorMatrixAssembler &global_assembler, VectorOfLocalAssemblers const &local_assemblers, std::vector< std::size_t > const &active_element_ids)
bool	isLinear () const

Private Attributes
bool const	is_linear_
std::unique_ptr< GlobalMatrix >	M_ {}
std::unique_ptr< GlobalMatrix >	K_ {}
std::unique_ptr< GlobalVector >	b_ {}

Constructor & Destructor Documentation

AssembledMatrixCache()

ProcessLib::AssembledMatrixCache::AssembledMatrixCache	(	bool const	is_linear,
		bool const	use_monolithic_scheme )

Definition at line 15 of file AssembledMatrixCache.cpp.

    : is_linear_{is_linear && use_monolithic_scheme}
{
    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 "
            "that optimization the process will be assembled only once and the "
            "non-linear solver will do only one iteration per time step. No "
            "non-linearities will be resolved and OGS will not detect if there "
            "are any non-linearities. It is your responsibility to ensure that "
            "the assembled equation systems are linear, indeed! There is no "
            "safety net!");
    }
}

References is_linear_, OGS_FATAL, and WARN().

Member Function Documentation

assemble()

template<typename VectorOfLocalAssemblers>

void ProcessLib::AssembledMatrixCache::assemble	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id,
		GlobalMatrix *const	M,
		GlobalMatrix *const	K,
		GlobalVector *const	b,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		VectorMatrixAssembler &	global_assembler,
		VectorOfLocalAssemblers const &	local_assemblers,
		std::vector< std::size_t > const &	active_element_ids )

Definition at line 53 of file AssembledMatrixCache.h.

{
    if (bool const cache_empty = K_ == nullptr; cache_empty)
    {
        BaseLib::RunTime time_asm;
        time_asm.start();
 
        // Call global assembler for each local assembly item.
        GlobalExecutor::executeSelectedMemberDereferenced(
            global_assembler, &VectorMatrixAssembler::assemble,
            local_assemblers, active_element_ids, dof_tables, t, dt, x, x_prev,
            process_id, M, K, b);
 
        MathLib::finalizeMatrixAssembly(*M);
        MathLib::finalizeMatrixAssembly(*K);
        MathLib::finalizeVectorAssembly(*b);
 
        INFO("[time] Calling local assemblers took {:g} s", time_asm.elapsed());
 
        if (is_linear_)
        {
            DBUG("Saving global K, M, b for later reuse.");
 
            BaseLib::RunTime time_save;
            time_save.start();
 
            K_ = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(*K);
            M_ = MathLib::MatrixVectorTraits<GlobalMatrix>::newInstance(*M);
            b_ = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(*b);
 
            INFO("[time] Saving global K, M, b took {:g} s",
                 time_save.elapsed());
        }
    }
    else
    {
        DBUG("Reusing saved global K, M, b.");
 
        BaseLib::RunTime time_restore;
        time_restore.start();
 
        MathLib::LinAlg::copy(*K_, *K);
        MathLib::LinAlg::copy(*M_, *M);
        MathLib::LinAlg::copy(*b_, *b);
 
        INFO("[time] Restoring global K, M, b took {:g} s",
             time_restore.elapsed());
    }
}

References ProcessLib::VectorMatrixAssembler::assemble(), b_, MathLib::LinAlg::copy(), DBUG(), BaseLib::RunTime::elapsed(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), MathLib::finalizeMatrixAssembly(), MathLib::finalizeVectorAssembly(), INFO(), is_linear_, K_, M_, and BaseLib::RunTime::start().

isLinear()

bool ProcessLib::AssembledMatrixCache::isLinear ( ) const

inline

Definition at line 42 of file AssembledMatrixCache.h.

{ return is_linear_; }

References is_linear_.

Member Data Documentation

b_

std::unique_ptr<GlobalVector> ProcessLib::AssembledMatrixCache::b_ {}

private

Definition at line 49 of file AssembledMatrixCache.h.

{};

Referenced by assemble().

is_linear_

bool const ProcessLib::AssembledMatrixCache::is_linear_

private

Definition at line 45 of file AssembledMatrixCache.h.

Referenced by AssembledMatrixCache(), assemble(), and isLinear().

K_

std::unique_ptr<GlobalMatrix> ProcessLib::AssembledMatrixCache::K_ {}

private

Definition at line 48 of file AssembledMatrixCache.h.

{};

Referenced by assemble().

M_

std::unique_ptr<GlobalMatrix> ProcessLib::AssembledMatrixCache::M_ {}

private

Definition at line 47 of file AssembledMatrixCache.h.

{};

Referenced by assemble().

---

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

• AssembledMatrixCache.h
• AssembledMatrixCache.cpp