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 &M, GlobalMatrix &K, GlobalVector &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 &	M,
		GlobalMatrix &	K,
		GlobalVector &	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());
    }
}