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());
    }
}