Detailed Description

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

Definition at line 121 of file MatrixElementCache.h.

#include <MatrixElementCache.h>

Collaboration diagram for ProcessLib::Assembly::MatrixElementCache< Dim >:

Public Member Functions
	MatrixElementCache (GlobalMatView &mat_or_vec, Stats &stats)
void	add (std::vector< double > const &local_data, std::vector< GlobalIndexType > const &indices)
	~MatrixElementCache ()

Private Types
using	GlobalMatView = ConcurrentMatrixView<Dim>

Private Member Functions
void	addToCache (std::vector< double > const &values, std::vector< GlobalIndexType > const &indices)
void	addToCacheImpl (std::vector< double > const &values, std::vector< GlobalIndexType > const &indices, std::integral_constant< std::size_t, 1 >)
void	addToCacheImpl (std::vector< double > const &values, std::vector< GlobalIndexType > const &indices, std::integral_constant< std::size_t, 2 >)
void	ensureEnoughSpace (std::size_t const space_needed)
void	addToGlobal ()

Private Attributes
std::vector< MatrixElementCacheEntry< Dim > >	cache_
GlobalMatView &	mat_or_vec_
Stats &	stats_

Static Private Attributes
static constexpr std::size_t	cache_capacity = 1'000'000

Member Typedef Documentation

◆ GlobalMatView

template<std::size_t Dim>

using ProcessLib::Assembly::MatrixElementCache< Dim >::GlobalMatView = ConcurrentMatrixView<Dim>

private

Definition at line 124 of file MatrixElementCache.h.

Constructor & Destructor Documentation

◆ MatrixElementCache()

template<std::size_t Dim>

ProcessLib::Assembly::MatrixElementCache< Dim >::MatrixElementCache	(	GlobalMatView &	mat_or_vec,
		Stats &	stats )

inline

Definition at line 129 of file MatrixElementCache.h.

        : mat_or_vec_(mat_or_vec), stats_(stats)
    {
        cache_.reserve(cache_capacity);
    }

References cache_, cache_capacity, mat_or_vec_, and stats_.

◆ ~MatrixElementCache()

template<std::size_t Dim>

ProcessLib::Assembly::MatrixElementCache< Dim >::~MatrixElementCache ( )

inline

Definition at line 141 of file MatrixElementCache.h.

141{ addToGlobal(); }

ProcessLib::Assembly::MatrixElementCache::addToGlobal

void addToGlobal()

Definition MatrixElementCache.h:243

References addToGlobal().

Member Function Documentation

◆ add()

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::add	(	std::vector< double > const &	local_data,
		std::vector< GlobalIndexType > const &	indices )

inline

Definition at line 135 of file MatrixElementCache.h.

    {
        addToCache(local_data, indices);
    }

References addToCache().

◆ addToCache()

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::addToCache	(	std::vector< double > const &	values,
		std::vector< GlobalIndexType > const &	indices )

inlineprivate

Definition at line 144 of file MatrixElementCache.h.

    {
        if (values.empty())
        {
            return;
        }
 
        ensureEnoughSpace(values.size());
 
        addToCacheImpl(values, indices,
                       std::integral_constant<std::size_t, Dim>{});
    }

References addToCacheImpl(), and ensureEnoughSpace().

Referenced by add().

◆ addToCacheImpl() [1/2]

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::addToCacheImpl	(	std::vector< double > const &	values,
		std::vector< GlobalIndexType > const &	indices,
		std::integral_constant< std::size_t, 1 >	)

inlineprivate

Definition at line 159 of file MatrixElementCache.h.

    {
        auto const num_r_c = indices.size();
 
        for (std::size_t r_local = 0; r_local < num_r_c; ++r_local)
        {
            ++stats_.count;
            auto const value = values[r_local];
 
            if (value == 0)
            {
                continue;
            }
            else
            {
                ++stats_.count_nonzero;
            }
 
            auto const r_global = indices[r_local];
            cache_.emplace_back(std::array{r_global}, value);
        }
    }

References cache_, and stats_.

Referenced by addToCache().

◆ addToCacheImpl() [2/2]

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::addToCacheImpl	(	std::vector< double > const &	values,
		std::vector< GlobalIndexType > const &	indices,
		std::integral_constant< std::size_t, 2 >	)

inlineprivate

Definition at line 185 of file MatrixElementCache.h.

    {
        auto const num_r_c = indices.size();
 
        // Note: There is an implicit storage order assumption, here!
        auto const local_mat = MathLib::toMatrix(values, num_r_c, num_r_c);
 
        for (std::size_t r_local = 0; r_local < num_r_c; ++r_local)
        {
            auto const r_global = indices[r_local];
 
            for (std::size_t c_local = 0; c_local < num_r_c; ++c_local)
            {
                ++stats_.count;
                auto const value = local_mat(r_local, c_local);
 
                // TODO skipping zero values sometimes does not work together
                // with the Eigen SparseLU linear solver. See also
                // https://gitlab.opengeosys.org/ogs/ogs/-/merge_requests/4556#note_125561
#if 0
                if (value == 0)
                {
                    continue;
                }
#endif
                ++stats_.count_nonzero;
 
                auto const c_global = indices[c_local];
                cache_.emplace_back(std::array{r_global, c_global}, value);
            }
        }
    }

References cache_, stats_, and MathLib::toMatrix().

◆ addToGlobal()

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::addToGlobal ( )

inlineprivate

Definition at line 243 of file MatrixElementCache.h.

    {
        mat_or_vec_.add(cache_);
        stats_.count_global += cache_.size();
        cache_.clear();
    }

References cache_, mat_or_vec_, and stats_.

Referenced by ~MatrixElementCache(), and ensureEnoughSpace().

◆ ensureEnoughSpace()

template<std::size_t Dim>

void ProcessLib::Assembly::MatrixElementCache< Dim >::ensureEnoughSpace ( std::size_t const space_needed )

inlineprivate

Definition at line 220 of file MatrixElementCache.h.

    {
        auto const size_initial = cache_.size();
        auto const cap_initial = cache_.capacity();
 
        if (size_initial + space_needed <= cap_initial)
        {
            return;
        }
 
        addToGlobal();
 
        // ensure again that there is enough capacity (corner case, if initial
        // capacity is too small because of whatever arcane reason)
        auto const size_after = cache_.size();
        auto const cap_after = cache_.capacity();
 
        if (size_after + space_needed > cap_after)
        {
            cache_.reserve(size_after + 2 * space_needed);
        }
    }