/home/brandes/workspace/LAMA/src/lama/matrix/DIASparseMatrix.hpp

Go to the documentation of this file.

#ifndef LAMA_DIA_SPARSE_MATRIX_HPP_
#define LAMA_DIA_SPARSE_MATRIX_HPP_

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

// base classes
#include <lama/matrix/SparseMatrix.hpp>

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

#include <lama/distribution/GeneralDistribution.hpp>

namespace lama
{

template<typename T>
class LAMA_DLL_IMPORTEXPORT DIASparseMatrix: public SparseMatrix<T>
{

public:

    typedef T ValueType; 

    typedef DIAStorage<T> StorageType;

    static const char* typeName();

    DIASparseMatrix() 

        : SparseMatrix<ValueType>( createStorage() )
    {
    }

    DIASparseMatrix( const IndexType numRows, const IndexType numColumns ) 

        : SparseMatrix<ValueType>( createStorage( numRows, numColumns ) )
    {
    }

    DIASparseMatrix( DistributionPtr rowDist, DistributionPtr colDist ) 

        : SparseMatrix<ValueType>( createStorage( rowDist->getLocalSize(), colDist->getGlobalSize() ),
                                   rowDist, colDist  )
    {
        // Note: splitting of local rows to local + halo part is done by SparseMatrix constructor
    }

    DIASparseMatrix( const Matrix& other, bool transposeFlag = false )

        : SparseMatrix<ValueType>( createStorage() )

    { 
        if( transposeFlag )
        {
            SparseMatrix<ValueType>::assignTranspose( other );
        }
        else
        {
            SparseMatrix<ValueType>::assign( other );
        }
    }

    DIASparseMatrix( const Matrix& other, DistributionPtr rowDist, DistributionPtr colDist )

        : SparseMatrix<ValueType>( createStorage() )

    { 
        // ToDo: this could be done better to avoid intermediate copies

        SparseMatrix<ValueType>::assign( other ); 
        this->redistribute( rowDist, colDist ); 
    }

    DIASparseMatrix( const _MatrixStorage& localData, DistributionPtr rowDist, DistributionPtr colDist )

        : SparseMatrix<ValueType>( createStorage() )

    {
        SparseMatrix<ValueType>::assign( localData, rowDist, colDist );
    }

    DIASparseMatrix( const std::string& filename )

        : SparseMatrix<ValueType>( createStorage() )

    { 
        this->readFromFile( filename );
    }

    // Expression constructors

    DIASparseMatrix( const Expression<Matrix, Matrix, Times>& expression )

        : SparseMatrix<ValueType>( createStorage() )
    {                                                   
        SparseMatrix<ValueType>::operator=( expression );
    }                                                  

    DIASparseMatrix( const Expression<Scalar, Matrix, Times>& expression )

        : SparseMatrix<ValueType>( createStorage() )
    {                                              
        SparseMatrix<ValueType>::operator=( expression ); 
    }                                                    

    DIASparseMatrix( const Expression<Scalar, Expression<Matrix, Matrix, Times>, Times>& expression )

        : SparseMatrix<ValueType>( createStorage() )
    {                                                     
        SparseMatrix<ValueType>::operator=( expression ); 
    }

    template<typename LocalValueType, typename HaloValueType>
    DIASparseMatrix( const IndexType numLocalRows,
                     const IndexType numLocalNonZeros,
                     const IndexType numHaloNonZeros,
                     const IndexType localIA[],
                     const IndexType localJA[],
                     const LocalValueType localValues[],
                     const IndexType haloIA[],
                     const IndexType haloJA[],
                     const HaloValueType haloValues[],
                     const std::vector<IndexType>& ownedIndexes,
                     const CommunicatorPtr communicator )

        : SparseMatrix<ValueType>( createStorage() )

{
    LAMA_LOG_INFO( logger, communicator << ": construct distributed matrix "
                    << numLocalRows << " by local and halo data + owned indexes" );

    // For the distribution we need the global number of rows, not available as arg, so compute it

    IndexType numGlobalRows = communicator->sum( numLocalRows );

    mLocalData->setRawCSRData( numLocalRows, numLocalRows, numLocalNonZeros, localIA, localJA, localValues );
    mHaloData->setRawCSRData( numLocalRows, numGlobalRows, numHaloNonZeros, haloIA, haloJA, haloValues );

    DistributionPtr dist( new GeneralDistribution( numGlobalRows, ownedIndexes, communicator ) );

    // Halo is already splitted, but still contains the global indexes

    mHaloData->buildHalo( mHalo, *dist );  // build halo, maps global indexes to halo indexes

    Matrix::setDistributedMatrix( dist, dist );
}

    virtual const StorageType& getLocalStorage() const;

    virtual StorageType& getLocalStorage();

    virtual const StorageType& getHaloStorage() const;

    virtual void swapLocalStorage( StorageType& localStorage );

    // ToDo: create, copy with covariant return types

    virtual const char* getTypeName() const;

protected:

    using SparseMatrix<ValueType>::mLocalData;
    using SparseMatrix<ValueType>::mHaloData;
    using SparseMatrix<ValueType>::mHalo;

private:

    boost::shared_ptr<MatrixStorage< ValueType> > createStorage() 
    {
        return boost::shared_ptr<MatrixStorage<ValueType> >( new StorageType() );
    }

    boost::shared_ptr<MatrixStorage< ValueType> > createStorage( const IndexType numRows, const IndexType numColumns ) 
    {
        boost::shared_ptr<MatrixStorage<ValueType> > storage( new StorageType() );
        storage->allocate( numRows, numColumns );
        return storage;
    }

    LAMA_LOG_DECL_STATIC_LOGGER( logger );
};


} // namespace lama

#endif // LAMA_DIA_SPARSE_MATRIX_HPP_