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
std::mutex	mutex_

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.

    {
        std::lock_guard<std::mutex> const lock(mutex_);
 
        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);
            }
        }
    }