BTASolver.h

#ifndef BTASOLVER_H
#define BTASOLVER_H
 
#include "mpi.h"
 
#include "Solver.h"
#include "../BTA/BTA.H"
#include "helper_functions.h"
//#include "BTA.H"
 
//#define PRINT_MSG
//#define PRINT_TIMES
//#define GFLOPS
 
/*
#if 0
typedef CPX T;
#define assign_T(val) CPX(val, 0.0)
#else
typedef double T;
#define assign_T(val) val
#endif
*/
 
 
class BTASolver: public Solver {
 
    private:
 
        int MPI_size;
        int MPI_rank;
 
        char processor_name[MPI_MAX_PROCESSOR_NAME];
        int name_len;
 
        int threads_level1;
        int thread_ID;
 
        /* matrix size */
        unsigned int nnz;       
        // to avoid redeclaration every time
        size_t i;
 
        int GPU_rank;
        // pardiso wants integer, BTA wants size_t, recast for now
        size_t ns_t;
        size_t nt_t;
        size_t nb_t;
        size_t no_t;
 
        size_t n;
 
        SpMat Q;                
        int* ia;                
        int* ja;                
        double* a;              
        double* b;              
        double* x;              
        BTA<double> *solver;    
        double dummy_time_1;
        double dummy_time_2;
 
    public:
        BTASolver(size_t ns_, size_t nt_, size_t nb_, size_t no_, int thread_ID_);
 
        void symbolic_factorization(SpMat& Q, int& init);
 
        void factorize(SpMat& Q, double& log_det, double& t_priorLatChol);
 
        // function description TODO ...
        void factorize_w_constr(SpMat& Q, const MatrixXd& D, double& log_det, MatrixXd& V);
 
        void factorize_solve(SpMat& Q, Vect& rhs, Vect& sol, double &log_det, double& t_condLatChol, double& t_condLatSolve);
 
        // function description TODO ...
        void factorize_solve_w_constr(SpMat& Q, Vect& rhs, const MatrixXd& Dxy, double &log_det, Vect& sol, MatrixXd& V);
 
        void selected_inversion(SpMat& Q, Vect& inv_diag);
 
        // function description TODO ... 
        void selected_inversion_w_constr(SpMat& Q, const MatrixXd& D, Vect& inv_diag, MatrixXd& V);
 
        // will also need a "simple inversion" method to independent of PARDISO. regular lapack should do (see pardiso)
        // OR not? Eigen function is probably fine, most likely also using lapack.
 
        ~BTASolver();
 
};
 
 
#endif