Detailed Description

Definition at line 13 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 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)
void	assemble (BaseLib::PolymorphicRandomAccessContainerView< LocalAssemblerInterface > const &local_assemblers, std::vector< std::size_t > const 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, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)

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 230 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

◆ assemble()

void ProcessLib::Assembly::ParallelVectorMatrixAssembler::assemble	(	BaseLib::PolymorphicRandomAccessContainerView< LocalAssemblerInterface > const &	local_assemblers,
		std::vector< std::size_t > const *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,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b )

Definition at line 238 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<2>>::create(num_threads_);
 
    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_M_data;
        std::vector<double> local_K_data;
        std::vector<double> local_b_data;
 
        // copy to avoid concurrent access
        auto const jac_asm = jacobian_assembler_.copy();
 
        auto stats_this_thread = stats->clone();
        MultiMatrixElementCache<2> cache{M, K, b, stats_this_thread->data,
                                         num_threads_};
 
        auto local_matrix_output = [&](std::ptrdiff_t element_id)
        {
            local_matrix_output_(t, process_id, element_id, local_M_data,
                                 local_K_data, local_b_data);
        };
 
        // 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(local_assemblers, active_elements, exception,
                        local_matrix_output,
                        [&](auto element_id, auto& loc_asm)
                        {
                            assembleOneElement(element_id, loc_asm, dof_table,
                                               t, dt, x, x_prev, local_M_data,
                                               local_K_data, local_b_data,
                                               cache);
                        });
        }
        else  // Staggered scheme
        {
            runAssembly(local_assemblers, active_elements, exception,
                        local_matrix_output,
                        [&](auto element_id, auto& loc_asm)
                        {
                            assembleForStaggeredSchemeOneElement(
                                element_id, loc_asm, dof_tables, t, dt, xs,
                                x_prevs, process_id, local_M_data, local_K_data,
                                local_b_data, cache);
                        });
        }
    }
 
    global_matrix_output_(t, process_id, M, K, b);
    exception.rethrow();
}

References global_matrix_output_, INFO(), jacobian_assembler_, local_matrix_output_, num_threads_, OGS_FATAL, and ThreadException::rethrow().

◆ assembleWithJacobian()

void ProcessLib::Assembly::ParallelVectorMatrixAssembler::assembleWithJacobian	(	BaseLib::PolymorphicRandomAccessContainerView< LocalAssemblerInterface > const &	local_assemblers,
		std::vector< std::size_t > const *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 324 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<1>>::create(num_threads_);
 
    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<1> cache{b, Jac, stats_this_thread->data,
                                         num_threads_};
 
        auto local_matrix_output = [&](std::ptrdiff_t element_id)
        {
            local_matrix_output_(t, process_id, element_id, local_b_data,
                                 local_Jac_data);
        };
 
        // 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(
                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(
                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();
}