Detailed Description

Definition at line 20 of file ParallelVectorMatrixAssembler.h.

#include <ParallelVectorMatrixAssembler.h>

Collaboration diagram for ProcessLib::Assembly::ParallelVectorMatrixAssembler:

Public Member Functions
	ParallelVectorMatrixAssembler (AbstractJacobianAssembler &jacobian_assembler)
void	assembleWithJacobian (BaseLib::PolymorphicRandomAccessContainerView< LocalAssemblerInterface > const &local_assemblers, std::vector< std::size_t > const &active_elements, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, const double t, double const dt, std::vector< GlobalVector * > const &xs, std::vector< GlobalVector * > const &x_prevs, int const process_id, GlobalVector &b, GlobalMatrix &Jac)

Private Attributes
AbstractJacobianAssembler &	jacobian_assembler_
LocalMatrixOutput	local_matrix_output_
GlobalMatrixOutput	global_matrix_output_
int const	num_threads_

Constructor & Destructor Documentation

◆ ParallelVectorMatrixAssembler()

ProcessLib::Assembly::ParallelVectorMatrixAssembler::ParallelVectorMatrixAssembler ( AbstractJacobianAssembler & jacobian_assembler )

explicit

Definition at line 177 of file ParallelVectorMatrixAssembler.cpp.

    : jacobian_assembler_{jacobian_assembler},
      num_threads_(BaseLib::getNumberOfAssemblyThreads())
{
    INFO("Threads used for ParallelVectorMatrixAssembler: {}.", num_threads_);
}

References INFO(), jacobian_assembler_, and num_threads_.

Member Function Documentation

◆ assembleWithJacobian()

void ProcessLib::Assembly::ParallelVectorMatrixAssembler::assembleWithJacobian	(	BaseLib::PolymorphicRandomAccessContainerView< LocalAssemblerInterface > const &	local_assemblers,
		std::vector< std::size_t > const &	active_elements,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	xs,
		std::vector< GlobalVector * > const &	x_prevs,
		int const	process_id,
		GlobalVector &	b,
		GlobalMatrix &	Jac )

Definition at line 185 of file ParallelVectorMatrixAssembler.cpp.

{
    // checks //////////////////////////////////////////////////////////////////
    if (dof_tables.size() != xs.size())
    {
        OGS_FATAL("Different number of DOF tables and solution vectors.");
    }
 
    std::size_t const number_of_processes = xs.size();
    // algorithm ///////////////////////////////////////////////////////////////
 
    auto stats = CumulativeStats<MultiStats>::create();
    ConcurrentMatrixView b_view(b);
    ConcurrentMatrixView Jac_view(Jac);
 
    ThreadException exception;
#pragma omp parallel num_threads(num_threads_)
    {
#ifdef _OPENMP
#pragma omp single nowait
        {
            INFO("Number of threads: {}", omp_get_num_threads());
        }
#endif
 
        // temporary data only stored here in order to avoid frequent memory
        // reallocations.
        std::vector<double> local_b_data;
        std::vector<double> local_Jac_data;
 
        // copy to avoid concurrent access
        auto const jac_asm = jacobian_assembler_.copy();
        auto stats_this_thread = stats->clone();
 
        MultiMatrixElementCache cache{b_view, Jac_view,
                                      stats_this_thread->data};
 
        auto local_matrix_output = [&](std::ptrdiff_t element_id)
        {
            local_matrix_output_(t, process_id, element_id, local_b_data,
                                 local_Jac_data);
        };
 
        // TODO corner case: what if all elements on a submesh are deactivated?
 
        // Monolithic scheme
        if (number_of_processes == 1)
        {
            assert(process_id == 0);
            auto const& dof_table = *dof_tables[0];
            auto const& x = *xs[0];
            auto const& x_prev = *x_prevs[0];
 
            runAssembly(
                collectActiveLocalAssemblers(local_assemblers, active_elements),
                exception, local_matrix_output,
                [&](auto element_id, auto& loc_asm)
                {
                    assembleWithJacobianOneElement(
                        element_id, loc_asm, dof_table, t, dt, x, x_prev,
                        local_b_data, local_Jac_data, *jac_asm, cache);
                });
        }
        else  // Staggered scheme
        {
            runAssembly(
                collectActiveLocalAssemblers(local_assemblers, active_elements),
                exception, local_matrix_output,
                [&](auto element_id, auto& loc_asm)
                {
                    assembleWithJacobianForStaggeredSchemeOneElement(
                        element_id, loc_asm, dof_tables, t, dt, xs, x_prevs,
                        process_id, local_b_data, local_Jac_data, *jac_asm,
                        cache);
                });
        }
    }
 
    stats->print();
 
    global_matrix_output_(t, process_id, b, Jac);
    exception.rethrow();
}