CSRMatrixData.h

Go to the documentation of this file.

#ifndef included_AMP_CSRMatrixData_h
#define included_AMP_CSRMatrixData_h
 
#include "AMP/matrices/MatrixParametersBase.h"
#include "AMP/matrices/RawCSRMatrixParameters.h"
#include "AMP/matrices/data/CSRLocalMatrixData.h"
#include "AMP/matrices/data/MatrixData.h"
#include "AMP/utils/Memory.h"
#include "AMP/utils/Utilities.h"
 
#include <functional>
#include <map>
#include <tuple>
#include <vector>
 
namespace AMP::IO {
class RestartManager;
}
 
namespace AMP::Discretization {
class DOFManager;
}
 
namespace AMP::LinearAlgebra {
 
template<typename C>
class CSRMatrixSpGEMMDefault;
 
template<typename Config>
class CSRMatrixData : public MatrixData
{
public:
    template<typename C>
    friend class CSRMatrixSpGEMMDefault;
    template<typename C>
    friend class CSRMatrixData;
 
    using gidx_t         = typename Config::gidx_t;
    using lidx_t         = typename Config::lidx_t;
    using scalar_t       = typename Config::scalar_t;
    using allocator_type = typename Config::allocator_type;
    static_assert( std::is_same_v<typename allocator_type::value_type, void> );
    using gidxAllocator_t =
        typename std::allocator_traits<allocator_type>::template rebind_alloc<gidx_t>;
    using lidxAllocator_t =
        typename std::allocator_traits<allocator_type>::template rebind_alloc<lidx_t>;
    using scalarAllocator_t =
        typename std::allocator_traits<allocator_type>::template rebind_alloc<scalar_t>;
    using localmatrixdata_t = CSRLocalMatrixData<Config>;
    using mask_t            = typename localmatrixdata_t::mask_t;
 
    explicit CSRMatrixData( std::shared_ptr<MatrixParametersBase> params );
 
    virtual ~CSRMatrixData();
 
    CSRMatrixData();
 
    CSRMatrixData( const CSRMatrixData & ) = delete;
 
    std::shared_ptr<MatrixData> cloneMatrixData() const override;
 
    template<typename ConfigOut>
    std::shared_ptr<CSRMatrixData<ConfigOut>> migrate( AMP::Utilities::Backend backend ) const;
 
    std::shared_ptr<MatrixData> transpose() const override;
 
    std::string type() const override { return "CSRMatrixData"; }
 
    virtual std::uint16_t mode() const override
    {
        return static_cast<std::uint16_t>( Config::mode );
    }
 
    void getRowByGlobalID( size_t row,
                           std::vector<size_t> &cols,
                           std::vector<double> &values ) const override;
 
    void addValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const void *values,
                              const typeID &id ) override;
 
    void setValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const void *values,
                              const typeID &id ) override;
 
    void getValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              void *values,
                              const typeID &id ) const override;
 
    size_t numberColumnIDs( size_t row ) const override;
 
    std::vector<size_t> getColumnIDs( size_t row ) const override;
 
    void makeConsistent( AMP::LinearAlgebra::ScatterType t ) override;
 
    std::shared_ptr<Discretization::DOFManager> getLeftDOFManager() const override;
 
    std::shared_ptr<Discretization::DOFManager> getRightDOFManager() const override;
 
    std::shared_ptr<CommunicationList> getLeftCommList() const;
 
    std::shared_ptr<CommunicationList> getRightCommList() const;
 
    size_t numLocalRows() const override;
 
    size_t numGlobalRows() const override;
 
    size_t numLocalColumns() const override;
 
    size_t numGlobalColumns() const override;
 
    size_t beginRow() const override;
 
    size_t endRow() const override;
 
    size_t beginCol() const override;
 
    size_t endCol() const override;
 
    typeID getCoeffType() const override
    {
        constexpr auto type = getTypeID<scalar_t>();
        return type;
    }
 
    std::shared_ptr<localmatrixdata_t> getDiagMatrix() { return d_diag_matrix; }
    std::shared_ptr<const localmatrixdata_t> getDiagMatrix() const { return d_diag_matrix; }
 
    std::shared_ptr<localmatrixdata_t> getOffdMatrix() { return d_offd_matrix; }
    std::shared_ptr<const localmatrixdata_t> getOffdMatrix() const { return d_offd_matrix; }
 
    lidx_t *getDiagRowStarts() { return d_diag_matrix->d_row_starts.get(); }
 
    lidx_t *getOffDiagRowStarts() { return d_offd_matrix->d_row_starts.get(); }
 
    bool isSquare() const noexcept { return d_is_square; }
 
    bool isEmpty() const noexcept { return d_diag_matrix->d_is_empty && d_offd_matrix->d_is_empty; }
 
    auto numberOfNonZeros() const { return d_diag_matrix->d_nnz + d_offd_matrix->d_nnz; }
 
    auto numberOfNonZerosDiag() const { return d_diag_matrix->d_nnz; }
 
    auto numberOfNonZerosOffDiag() const { return d_offd_matrix->d_nnz; }
 
    bool hasOffDiag() const { return !d_offd_matrix->d_is_empty; }
 
    auto getMemoryLocation() const { return d_memory_location; }
 
    void setNNZ( lidx_t tot_nnz_diag, lidx_t tot_nnz_offd );
 
    void setNNZ( const lidx_t *nnz_diag, const lidx_t *nnz_offd );
 
    void setNNZ( bool do_accum );
 
    void globalToLocalColumns();
 
    void resetDOFManagers( bool force_dm_reset = false );
 
    void assemble( bool force_dm_reset = false );
 
    void removeRange( AMP::Scalar bnd_lo, AMP::Scalar bnd_up ) override;
 
    void printStats( bool verbose, bool show_zeros ) const
    {
        std::cout << "CSRMatrixData stats:" << std::endl;
        std::cout << "  Memory location: " << AMP::Utilities::getString( d_memory_location )
                  << std::endl;
        std::cout << "  Global size: (" << numGlobalRows() << " x " << numGlobalColumns() << ")"
                  << std::endl;
        d_diag_matrix->printStats( verbose, show_zeros );
        d_offd_matrix->printStats( verbose, show_zeros );
    }
 
    std::shared_ptr<localmatrixdata_t> subsetRows( const std::vector<gidx_t> &rows ) const;
 
    std::shared_ptr<localmatrixdata_t>
    subsetCols( const gidx_t idx_lo, const gidx_t idx_up, const bool is_diag ) const;
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
    void writeRestart( int64_t fid ) const override;
 
    CSRMatrixData( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:
    void setOtherData( std::map<gidx_t, std::map<gidx_t, scalar_t>> &,
                       AMP::LinearAlgebra::ScatterType );
 
    std::shared_ptr<localmatrixdata_t>
    transposeOffd( std::shared_ptr<MatrixParametersBase> params ) const;
 
    void writeRestartMapData( const int64_t fid,
                              const std::string &prefix,
                              const std::map<gidx_t, std::map<gidx_t, scalar_t>> &data ) const;
 
    void readRestartMapData( const int64_t fid,
                             const std::string &prefix,
                             std::map<gidx_t, std::map<gidx_t, scalar_t>> &data );
 
public:
    AMP::Utilities::MemoryType d_memory_location;
 
protected:
    bool d_is_square = true;
    gidx_t d_first_row = 0;
    gidx_t d_last_row = 0;
    gidx_t d_first_col = 0;
    gidx_t d_last_col = 0;
 
    mutable gidxAllocator_t d_gidxAllocator;
    mutable lidxAllocator_t d_lidxAllocator;
    mutable scalarAllocator_t d_scalarAllocator;
 
    std::shared_ptr<localmatrixdata_t> d_diag_matrix;
    std::shared_ptr<localmatrixdata_t> d_offd_matrix;
 
    std::shared_ptr<Discretization::DOFManager> d_leftDOFManager;
    std::shared_ptr<Discretization::DOFManager> d_rightDOFManager;
 
    std::shared_ptr<CommunicationList> d_leftCommList;
    std::shared_ptr<CommunicationList> d_rightCommList;
 
    std::map<gidx_t, std::map<gidx_t, scalar_t>> d_other_data;
 
    std::map<gidx_t, std::map<gidx_t, scalar_t>> d_ghost_data;
};
 
template<typename Config>
static CSRMatrixData<Config> const *getCSRMatrixData( MatrixData const &A )
{
    auto ptr = dynamic_cast<CSRMatrixData<Config> const *>( &A );
    AMP_INSIST( ptr, "dynamic cast from const MatrixData to const CSRMatrixData failed" );
    return ptr;
}
 
template<typename Config>
static CSRMatrixData<Config> *getCSRMatrixData( MatrixData &A )
{
    auto ptr = dynamic_cast<CSRMatrixData<Config> *>( &A );
    AMP_INSIST( ptr, "dynamic cast from MatrixData to CSRMatrixData failed" );
    return ptr;
}
 
} // namespace AMP::LinearAlgebra
 
#endif