/home/brandes/workspace/LAMA/src/lama/storage/SparseAssemblyStorage.hpp

Go to the documentation of this file.

#ifndef LAMA_SPARSEASSEMBLYSTORAGE_HPP_
#define LAMA_SPARSEASSEMBLYSTORAGE_HPP_

// for dll_import
#include <lama/config.hpp>

// others
#include <lama/storage/CRTPMatrixStorage.hpp>

namespace lama
{

template<typename T>
class LAMA_DLL_IMPORTEXPORT SparseAssemblyStorage: 

    public CRTPMatrixStorage<SparseAssemblyStorage<T>, T>
{
public:
    typedef T ValueType;

    static const char* typeName();

    SparseAssemblyStorage();

    SparseAssemblyStorage( const SparseAssemblyStorage<ValueType>& other );

    explicit SparseAssemblyStorage( const _MatrixStorage& other );

    SparseAssemblyStorage(
        const IndexType numRows,
        const IndexType numColumns,
        const IndexType numValuesPerRow = 10);

    virtual ~SparseAssemblyStorage();

    virtual void writeAt(std::ostream& stream) const;

    virtual void clear();

    virtual void purge();

    void swap( SparseAssemblyStorage<ValueType>& other );

    void allocate(const IndexType numRows, const IndexType numColumns );

    SparseAssemblyStorage<T>& operator=( const SparseAssemblyStorage<T>& other );

    SparseAssemblyStorage<T>& operator=( const _MatrixStorage& other );

    ValueType operator()( const IndexType i, const IndexType j ) const;

    ValueType getValue( const IndexType i, const IndexType j ) const
    {
        return (*this)( i, j );
    }

    virtual MatrixStorageFormat getFormat() const;

    virtual void setIdentity(const IndexType size);

    void set(const IndexType i,const IndexType j, const ValueType value);

    const std::vector<IndexType>& getJa(const IndexType i) const;

    std::vector<IndexType>& getJa(const IndexType i);

    const std::vector<ValueType>& getValues(const IndexType i) const;

    virtual void prefetch( const ContextPtr location ) const;

    void wait() const;

    IndexType getNumValues() const;

    virtual size_t getMemoryUsageImpl() const;

    void setRow(
        const IndexType i,
        const LAMAArrayConstView<IndexType>& ja,
        const LAMAArrayConstView<ValueType>& a);

    void fixDiagonalProperty(const IndexType i);

    void setNumColumns(const IndexType i);

    template<typename OtherType>
    void getRowImpl( LAMAArray<OtherType>& row, const IndexType i ) const;

    template<typename OtherValueType>
    void getDiagonalImpl( LAMAArray<OtherValueType>& diagonal ) const;

    template<typename OtherValueType>
    void setDiagonalImpl( const LAMAArray<OtherValueType>& diagonal );

    void setDiagonalImpl( const Scalar scalar );

    /******************************************************************
    *  Scaling of elements in a matrix                                *
    ******************************************************************/

    template<typename OtherType>
    void scaleImpl( const LAMAArray<OtherType>& values );

    void scaleImpl( const Scalar value );

    template<typename OtherValueType>
    void buildCSR( LAMAArray<IndexType>& ia,
                   LAMAArray<IndexType>* ja,
                   LAMAArray<OtherValueType>* values,
                   const ContextPtr /* loc */ ) const;

    template<typename OtherValueType>
    void setCSRDataImpl( const IndexType numRows,
                         const IndexType numColumns,
                         const IndexType numValues,
                         const LAMAArray<IndexType>& ia,
                         const LAMAArray<IndexType>& ja,
                         const LAMAArray<OtherValueType>& values,
                         const ContextPtr loc );

    void check( const char* msg ) const;

    virtual SparseAssemblyStorage* copy() const
    {
        return new SparseAssemblyStorage( *this );
    }

    virtual SparseAssemblyStorage* create() const
    {
        return new SparseAssemblyStorage();
    }

    using MatrixStorage<ValueType>::assign;

private:

    void print() const;

    using CRTPMatrixStorage<SparseAssemblyStorage<T>, T>::mDiagonalProperty;
    using CRTPMatrixStorage<SparseAssemblyStorage<T>, T>::mNumRows;
    using CRTPMatrixStorage<SparseAssemblyStorage<T>, T>::mNumColumns;

    struct Row
    {
        std::vector<IndexType> ja;
        std::vector<ValueType> values;
        Row();
        Row( const Row& other );
        Row( const IndexType numValuesPerRow );
        Row& operator=( const Row& other );
        void reserve(const IndexType numValuesPerRow);
        void scale( const ValueType val );
    };

    std::vector<Row> mRows;

    IndexType mNumValues;  

    virtual bool checkDiagonalProperty() const;

    LAMA_LOG_DECL_STATIC_LOGGER( logger );
};

} //namespace lama

#endif // LAMA_SPARSEASSEMBLYSTORAGE_HPP_