/home/brandes/workspace/LAMA/src/lama/solver/Solver.hpp

Go to the documentation of this file.

#ifndef LAMA_SOLVER_HPP_
#define LAMA_SOLVER_HPP_

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

// base classes
#include <lama/NonCopyable.hpp>

// others
#include <lama/Vector.hpp>
#include <lama/Printable.hpp>

#include <lama/matrix/Matrix.hpp>

#include <lama/solver/SolutionProxy.hpp>
#include <lama/solver/logger/Logger.hpp>

// logging
#include <logging/logging.hpp>

#include <string>
#include <memory>

namespace lama
{

class Solver;
typedef boost::shared_ptr<Solver> SolverPtr;

class LAMA_DLL_IMPORTEXPORT Solver : public Printable
{
public:
    Solver(const std::string& id);

    Solver(const std::string& id, LoggerPtr logger);

    Solver( const Solver& other );

    virtual ~Solver();

    virtual void initialize( const Matrix& coefficients );

    virtual void solve( Vector& solution, const Vector& rhs );

    virtual void solveInit( Vector& solution, const Vector& rhs );

    virtual void solveImpl() = 0;

    virtual void solveFinalize();

    const std::string& getId() const;

    const Vector& getResidual() const;

    const Matrix& getCoefficients() const;

    void setLogger( LoggerPtr logger );

    void setLogLevel(LogLevel::LogLevel level);

    virtual void setContext( ContextPtr context );

    virtual SolverPtr copy() =0;

    struct SolverRuntime : public NonCopyable
    {
        SolverRuntime();
        virtual ~SolverRuntime();
        
        const Matrix* mCoefficients;

        const Vector* mRhs;

        mutable SolutionProxy mSolution;

        mutable std::auto_ptr<Vector> mResidual;

        bool mInitialized;

        bool mSolveInit;
    };

    virtual SolverRuntime& getRuntime() =0;


    virtual const SolverRuntime& getConstRuntime() const =0;

protected:

    std::string mId;

    LoggerPtr mLogger;

    ContextPtr mContext;

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

    LAMA_LOG_DECL_STATIC_LOGGER(logger);
};

} // namespace lama

#endif // LAMA_SOLVER_HPP_