inmost_solver.h

#ifndef INMOST_SOLVER_INCLUDED
#define INMOST_SOLVER_INCLUDED
 
#include "inmost_common.h"
#include "inmost_sparse.h"
 
#if defined(USE_SOLVER)
namespace INMOST {
 
    class SolverInterface;
 
    class SolverParameters;
 
    enum SolverVerbosityLevel {
        SolverVerbosityLevel0 = 0,
        SolverVerbosityLevel1 = 1,
        SolverVerbosityLevel2 = 2
    };
 
    class Solver {
    public:
        //Backward-compatibility
        typedef std::string Type;
        static const Type   INNER_ILU2;     
        static const Type   INNER_DDPQILUC; 
        static const Type   INNER_MPTILUC;  
        static const Type   INNER_MLMPTILUC;  
        static const Type   INNER_MPTILU2;  
        static const Type   Trilinos_Aztec; 
        static const Type   Trilinos_Belos; 
        static const Type   Trilinos_ML;    
        static const Type   Trilinos_Ifpack;
        static const Type   PETSc;          
        static const Type   ANI;            
        static const Type   FCBIILU2;       
        static const Type   K3BIILU2;       
        static const Type   SUPERLU;        
        void SetParameterEnum(std::string name, INMOST_DATA_ENUM_TYPE value);
 
        void SetParameterReal(std::string name, INMOST_DATA_REAL_TYPE value);
 
        std::string GetReason() { return ReturnReason(); }
        //Backward-compatibility
    private:
        static std::vector<SolverParameters> parameters; 
        static int                           *argc; 
        static char                          ***argv; 
        static bool                          is_initialized; 
        static bool                          is_finalized; 
        SolverInterface                      *solver; 
        std::string                          prefix; 
        SolverVerbosityLevel                 versbosity;
        double                               preconditioner_time;
        double                               iterations_time;
        bool                                 is_solved;
 
        static void parseXMLDatabase(const char *xml_database);
 
    public:
        class OrderInfo {
        private:
            typedef std::vector<INMOST_DATA_ENUM_TYPE> storage_type; 
            storage_type                               global_to_proc; 
            storage_type                               global_overlap; 
            std::vector<INMOST_DATA_ENUM_TYPE>         vector_exchange_recv; 
            std::vector<INMOST_DATA_ENUM_TYPE>         vector_exchange_send; 
            std::vector<INMOST_DATA_REAL_TYPE>         send_storage; 
            std::vector<INMOST_DATA_REAL_TYPE>         recv_storage; 
            std::vector<INMOST_MPI_Request>            send_requests; 
            std::vector<INMOST_MPI_Request>            recv_requests; 
            std::vector<INMOST_DATA_ENUM_TYPE>         extended_indexes; 
            INMOST_DATA_ENUM_TYPE local_vector_begin; 
            INMOST_DATA_ENUM_TYPE local_vector_end; 
            INMOST_DATA_ENUM_TYPE initial_matrix_begin; 
            INMOST_DATA_ENUM_TYPE initial_matrix_end; 
            INMOST_DATA_ENUM_TYPE local_matrix_begin; 
            INMOST_DATA_ENUM_TYPE local_matrix_end; 
            bool                                       have_matrix; 
            INMOST_MPI_Comm       comm; 
            int                                        rank; 
            int                                        size; 
        public:
            void Clear();
 
            bool &HaveMatrix() { return have_matrix; }
 
            OrderInfo();
 
            OrderInfo(const OrderInfo &other);
 
            OrderInfo &operator=(OrderInfo const &other);
 
            ~OrderInfo();
 
            void PrepareMatrix(Sparse::Matrix &m, INMOST_DATA_ENUM_TYPE overlap);
 
            void RestoreMatrix(Sparse::Matrix &m);
 
            void PrepareVector(Sparse::Vector &v) const;
 
            void RestoreVector(Sparse::Vector &v) const;
            INMOST_DATA_ENUM_TYPE GetProcessor(INMOST_DATA_ENUM_TYPE gind) const;
 
            void GetOverlapRegion(INMOST_DATA_ENUM_TYPE proc, INMOST_DATA_ENUM_TYPE &mbeg, INMOST_DATA_ENUM_TYPE &mend) const;
 
            void GetLocalRegion(INMOST_DATA_ENUM_TYPE proc, INMOST_DATA_ENUM_TYPE &mbeg, INMOST_DATA_ENUM_TYPE &mend) const;
 
            void GetVectorRegion(INMOST_DATA_ENUM_TYPE &mbeg, INMOST_DATA_ENUM_TYPE &mend) const {
                mbeg = local_vector_begin;
                mend = local_vector_end;
            }
            INMOST_DATA_ENUM_TYPE GetRank() const { return rank; }
            INMOST_DATA_ENUM_TYPE GetSize() const { return size; }
 
            void Update(Sparse::Vector &x);
 
            void Accumulate(Sparse::Vector &x);
 
            void Integrate(INMOST_DATA_REAL_TYPE *inout, INMOST_DATA_ENUM_TYPE num) const;
            INMOST_MPI_Comm GetComm() const { return comm; }
            INMOST_MPI_Request *GetSendRequests() {
                assert(!send_requests.empty());
                return &send_requests[0];
            }
            INMOST_MPI_Request *GetRecvRequests() {
                assert(!recv_requests.empty());
                return &recv_requests[0];
            }
            INMOST_DATA_ENUM_TYPE GetSendRequestsSize() { return static_cast<INMOST_DATA_ENUM_TYPE>(send_requests.size()); }
            INMOST_DATA_ENUM_TYPE GetRecvRequestsSize() { return static_cast<INMOST_DATA_ENUM_TYPE>(recv_requests.size()); }
            INMOST_DATA_ENUM_TYPE *GetSendExchangeArray() {
                assert(!vector_exchange_send.empty());
                return &vector_exchange_send[0];
            }
            INMOST_DATA_ENUM_TYPE GetSendExchangeSize() { return static_cast<INMOST_DATA_ENUM_TYPE>(send_storage.size()); }
            INMOST_DATA_ENUM_TYPE *GetRecvExchangeArray() {
                assert(!vector_exchange_recv.empty());
                return &vector_exchange_recv[0];
            }
            INMOST_DATA_ENUM_TYPE GetRecvExchangeSize() { return static_cast<INMOST_DATA_ENUM_TYPE>(recv_storage.size()); }
            //void BeginSequentialCode() {for(int i = 0; i < rank; i++) MPI_Barrier(comm);}
            //void EndSequentialCode() {for(int i = rank; i < size; i++) MPI_Barrier(comm);}
        };
 
        Solver(std::string solverName, std::string prefix = "", INMOST_MPI_Comm _comm = INMOST_MPI_COMM_WORLD);
 
        Solver(const Solver &other);
 
        Solver &operator=(const Solver &other);
 
        std::string SolverName() const;
 
        std::string SolverPrefix() const;
 
        SolverVerbosityLevel VerbosityLevel() const;
 
        void SetVerbosityLevel(SolverVerbosityLevel level);
 
        static void Initialize(int *argc, char ***argv, const char *database = NULL);
 
        static void Finalize();
 
        static bool isInitialized();
 
        static bool isFinalized();
 
        void SetMatrix(Sparse::Matrix &A, bool ModifiedPattern = true, bool OldPreconditioner = false);
 
        bool Solve(Sparse::Vector &RHS, Sparse::Vector &SOL);
 
        bool Clear();
 
        std::string GetParameter(std::string name) const;
 
        void SetParameter(std::string name, std::string value);
        INMOST_DATA_ENUM_TYPE Iterations() const;
        INMOST_DATA_REAL_TYPE Residual() const;
 
        const std::string ReturnReason() const;
 
        double PreconditionerTime() const;
 
        double IterationsTime() const;
 
        bool IsSolved() const;
 
        const std::string SolutionMetadataLine(const std::string &delimiter) const;
        INMOST_DATA_REAL_TYPE Condest(INMOST_DATA_REAL_TYPE tol, INMOST_DATA_ENUM_TYPE maxits = 100);
 
        static bool isSolverAvailable(std::string name);
 
        static std::vector<std::string> getAvailableSolvers();
 
        ~Solver();
    };
 
    typedef std::vector<std::string>::iterator solvers_names_iterator_t;
    typedef std::vector<SolverParameters>::iterator solver_parameters_iterator_t;
 
    namespace TTSP {
 
        void Initialize(const std::string &path);
 
        void Deinitialize();
 
        void Enable(const std::string &solver_name, const std::string &solver_prefix);
 
        void Disable(const std::string &solver_name, const std::string &solver_prefix);
 
        bool isEnabled(const std::string &solver_name, const std::string &solver_prefix);
 
        bool isDisabled(const std::string &solver_name, const std::string &solver_prefix);
 
        void SolverOptimize(Solver &solver, bool use_last_suggestion = false);
 
        void SolverOptimizeSaveResult(Solver &solver, double metrics, bool is_good);
 
        void DestroySavedOptimizer(Solver &solver);
 
    }
 
}
 
#endif
 
#endif //INMOST_SOLVER_INCLUDED