Detailed Description

template<std::size_t Dim>
class ProcessLib::Assembly::ConcurrentMatrixView< Dim >

Definition at line 67 of file MatrixElementCache.h.

#include <MatrixElementCache.h>

Public Member Functions
	ConcurrentMatrixView (GlobalMatOrVec &mat_or_vec)

void	add (std::vector< MatrixElementCacheEntry< Dim > > const &entries)

Private Types
using	GlobalMatOrVec

Private Attributes
GlobalMatOrVec &	mat_or_vec_

Member Typedef Documentation

◆ GlobalMatOrVec

template<std::size_t Dim>

using ProcessLib::Assembly::ConcurrentMatrixView< Dim >::GlobalMatOrVec

private

Initial value:

std::conditional_t<Dim == 1, GlobalVector, GlobalMatrix>

Definition at line 70 of file MatrixElementCache.h.

Constructor & Destructor Documentation

◆ ConcurrentMatrixView()

template<std::size_t Dim>

ProcessLib::Assembly::ConcurrentMatrixView< Dim >::ConcurrentMatrixView ( GlobalMatOrVec & mat_or_vec )

inlineexplicit

Definition at line 74 of file MatrixElementCache.h.

        : mat_or_vec_{mat_or_vec}
    {
    }

Member Function Documentation

◆ add()

template<std::size_t Dim>

void ProcessLib::Assembly::ConcurrentMatrixView< Dim >::add ( std::vector< MatrixElementCacheEntry< Dim > > const & entries )

inline

Definition at line 79 of file MatrixElementCache.h.

    {
#pragma omp critical
        {
            if constexpr (Dim == 2)
            {
                auto const n_cols = mat_or_vec_.getNumberOfColumns();
 
                // TODO would be more efficient if our global matrix and vector
                // implementations supported batch addition of matrix elements
                // with arbitrary indices (not restricted to (n x m) shaped
                // submatrices).
                for (auto const [rc, value] : entries)
                {
                    auto const [r, c] = rc;
 
                    auto const c_no_ghost =
                        detail::transformToNonGhostIndex(c, n_cols);
 
                    mat_or_vec_.add(r, c_no_ghost, value);
                }
            }
            else
            {
                // TODO batch addition would be more efficient. That needs the
                // refactoring of the matrix element cache.
                for (auto const [r, value] : entries)
                {
                    mat_or_vec_.add(r.front(), value);
                }
            }
        }
    }