Detailed Description

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

Definition at line 120 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 123 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 128 of file MatrixElementCache.h.

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

References ProcessLib::Assembly::MatrixElementCache< Dim >::cache_, and ProcessLib::Assembly::MatrixElementCache< Dim >::cache_capacity.

◆ ~MatrixElementCache()

template<std::size_t Dim>

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

inline

Definition at line 140 of file MatrixElementCache.h.

140{ addToGlobal(); }

ProcessLib::Assembly::MatrixElementCache::addToGlobal

void addToGlobal()

Definition MatrixElementCache.h:242

References ProcessLib::Assembly::MatrixElementCache< Dim >::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 134 of file MatrixElementCache.h.

    {
        addToCache(local_data, indices);
    }

References ProcessLib::Assembly::MatrixElementCache< Dim >::addToCache().

Referenced by ProcessLib::Assembly::MultiMatrixElementCache::add().

◆ 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 143 of file MatrixElementCache.h.

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

References ProcessLib::Assembly::MatrixElementCache< Dim >::addToCacheImpl(), and ProcessLib::Assembly::MatrixElementCache< Dim >::ensureEnoughSpace().

Referenced by ProcessLib::Assembly::MatrixElementCache< Dim >::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 158 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 ProcessLib::Assembly::MatrixElementCache< Dim >::cache_, ProcessLib::Assembly::Stats::count, ProcessLib::Assembly::Stats::count_nonzero, and ProcessLib::Assembly::MatrixElementCache< Dim >::stats_.

Referenced by ProcessLib::Assembly::MatrixElementCache< Dim >::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 184 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 ProcessLib::Assembly::MatrixElementCache< Dim >::cache_, ProcessLib::Assembly::Stats::count, ProcessLib::Assembly::Stats::count_nonzero, ProcessLib::Assembly::MatrixElementCache< Dim >::stats_, and MathLib::toMatrix().

◆ addToGlobal()

template<std::size_t Dim>

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

inlineprivate

Definition at line 242 of file MatrixElementCache.h.

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

References ProcessLib::Assembly::ConcurrentMatrixView< Dim >::add(), ProcessLib::Assembly::MatrixElementCache< Dim >::cache_, ProcessLib::Assembly::Stats::count_global, ProcessLib::Assembly::MatrixElementCache< Dim >::mat_or_vec_, and ProcessLib::Assembly::MatrixElementCache< Dim >::stats_.

Referenced by ProcessLib::Assembly::MatrixElementCache< Dim >::~MatrixElementCache(), and ProcessLib::Assembly::MatrixElementCache< Dim >::ensureEnoughSpace().

◆ ensureEnoughSpace()

template<std::size_t Dim>

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

inlineprivate

Definition at line 219 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);
        }
    }