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

Go to the documentation of this file.

#ifndef LAMA_METAMATRIX_HPP_
#define LAMA_METAMATRIX_HPP_

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

// base classes
#include <lama/matrix/Matrix.hpp>
#include <lama/distribution/Distribution.hpp>
#include <lama/Context.hpp>
#include <lama/CommunicatorManager.hpp>
#include <lama/CommunicatorFactory.hpp>

// spirit
#include <boost/spirit/include/qi.hpp>

#include <string>
#include <fstream>

namespace lama
{

namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

class LAMA_DLL_IMPORTEXPORT MetaMatrix : public Matrix
{
public:
    typedef std::string::const_iterator StringIterator;

    MetaMatrix( Matrix& other, const std::string& config );

    virtual ~MetaMatrix();

    /*
     * @brief If arg is a file it reads the files content. If not it calls the direct interpretation
     *
     * @param[in] arg   Input string which is a file name or a configuration string
     */
    void interpreteArgument( Matrix& other, const std::string& arg );

    /*
     * @brief Parses the given configuration and constructs the MetaMatrix
     *
     * Parses the given configuration in mConfiguration and constructs the MetaMatrix with the
     * described settings.
     */
    void parseConfiguration( Matrix& other, const std::string& configuration );

    // **** Forward methods to provide matrix functionality ****

    virtual const char* getTypeName() const;

    virtual void clear();

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

    virtual void allocate( DistributionPtr rowDistribution, DistributionPtr colDistribution );

    virtual void setIdentity();

    virtual void assign( const Matrix& other );

    virtual void assign( const _MatrixStorage& other );

    virtual void assign( const _MatrixStorage& storage, DistributionPtr rowDist, DistributionPtr colDist );

    virtual void buildLocalStorage( _MatrixStorage& storage ) const;

    virtual void redistribute( DistributionPtr rowDistribution , DistributionPtr colDistribution );

    virtual void getRow( Vector& row, const IndexType globalRowIndex ) const;

    virtual void getDiagonal( Vector& diagonal ) const;

    virtual void setDiagonal( const Vector& diagonal );

    virtual void setDiagonal( const Scalar scalar );

    virtual void scale( const Vector& scaling );

    virtual void scale( const Scalar scaling );

    virtual Scalar getValue( IndexType i, IndexType j ) const;

    virtual IndexType getNumValues() const;

    virtual void matrixTimesVector(
        Vector& result, const Scalar alpha, const Vector& x,
        const Scalar beta, const Vector& y ) const;

    virtual void matrixTimesScalar(
        const Matrix& other, const Scalar alpha );

    virtual void matrixTimesMatrix(
        Matrix& result, const Scalar alpha, const Matrix& B,
        const Scalar beta, const Matrix& C ) const;

    virtual IndexType getLocalNumValues() const;

    virtual IndexType getLocalNumRows() const;

    virtual IndexType getLocalNumColumns() const;

    virtual void setContext( const ContextPtr context );

    virtual ContextPtr getContextPtr() const;

    virtual MatrixKind getMatrixKind() const;

    virtual void prefetch() const;

    virtual void wait() const;

    virtual void invert( const Matrix& other );

    virtual Scalar maxDiffNorm( const Matrix& other ) const;

    virtual std::auto_ptr<Matrix> create() const;

    virtual std::auto_ptr<Matrix> copy() const;

    virtual Scalar::ScalarType getValueType() const;

    virtual bool hasDiagonalProperty() const;

    virtual void resetDiagonalProperty();

    virtual size_t getMemoryUsage() const;

private:
    MatrixPtr mMatrix;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

};

class MatrixConfigGrammar :
    public qi::grammar<std::string::const_iterator, MatrixPtr( Matrix* ), qi::locals<Matrix*>, ascii::space_type>
{
public:
    typedef std::string::const_iterator StringIterator;
    MatrixConfigGrammar();

private:
    qi::rule<StringIterator, MatrixPtr( Matrix* ), qi::locals<Matrix*>, ascii::space_type>
                    mRMatrixConfiguration;

    qi::rule<StringIterator, Matrix*( Matrix* ), ascii::space_type> mRType;

    qi::rule<StringIterator, void( Matrix* ), ascii::space_type> mRContextDef;

    qi::rule<StringIterator, ContextPtr(), ascii::space_type> mRContext;

    qi::rule<StringIterator, ContextManager*(), ascii::space_type> mRContextManager;

    qi::symbols<char, Context::ContextType> mRContextMap;

    qi::rule<StringIterator, void( Matrix* ), ascii::space_type> mRDistributions;

    qi::rule<StringIterator, DistributionPtr( int ), ascii::space_type> mRDistribution;

    qi::rule<StringIterator, CommunicatorPtr(), ascii::space_type> mRComm;

    qi::rule<StringIterator, boost::shared_ptr<CommunicatorManager>(), ascii::space_type> mRCommMan;

    qi::rule<StringIterator, std::string()> mRId;

    MatrixPtr mMatrix;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);
};

} //namespace lama

#endif /* LAMA_METAMATRIX_HPP_ */