EigenSolver.h

#ifndef EIGEN_CHOL_SOLVER_H
#define EIGEN_SOLVER_H
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iomanip>
 
#include <fstream>
#include <iostream>
 
#include <Eigen/Core>
#include <Eigen/Dense>
#include <Eigen/SparseCore>
#include <Eigen/SparseCholesky>
#include <Eigen/CholmodSupport>
 
#include "Solver.h"
 
//#define PRINT_PAR
//#define PRINT_OMP
 
// get gflops manually from pardiso output
//#define MEAS_GFLOPS
 
typedef Eigen::VectorXd Vect;
typedef Eigen::SparseMatrix<double> SpMat;
 
using namespace Eigen;
 
class EigenSolver : public Solver{
 
private:
 
 
    int MPI_rank;           
    int init = 0;
 
    /* matrix size */
    int n;                  
    long unsigned int nnz;       
    SpMat Q;                
    int* ia;                
    int* ja;                
    double* a;              
    double* b;              
    double* x;              
    SimplicialLLT<SpMat> solverEigenQ;
 
 
public:
    EigenSolver(int& MPI_rank);
 
 
    /* ======================================================================== */
    void symbolic_factorization(SpMat& Q, int& init);
 
 
    void factorize(SpMat& Q, double& log_det, double& t_priorLatChol);
 
    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);
 
    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);
 
    void selected_inversion_w_constr(SpMat& Q, const MatrixXd& D, Vect& inv_diag, MatrixXd& V);
 
 
    void compute_full_inverse(MatrixXd& H, MatrixXd& C);
 
 
    ~EigenSolver();
 
}; // end class
 
 
#endif