PartialLinearSolver.h

 
#pragma once
 
/*#include "SparseMatrixBuilder.h"
 
namespace CoRiBoDynamics
{
class PartialLinearSolver{
public:
    explicit PartialLinearSolver(SparseMatrixBuilder* matrix){
        m_matrix = matrix;
    }
    virtual ~PartialLinearSolver(){}
    virtual void Compute() = 0;
    virtual void Solve(const Vector& B, Vector& X) = 0; /// Solve for A*X=B. Not inherintly thread safe. 
 
    mat6* MainDiagonal(){return m_matrix->m_A_0_diagonal;}
    mat6* FirstDiagonal(){return m_matrix->m_A_1_diagonal;}
    std::vector<Eigen::SparseVector<mat6*> >* OffDiagonal(){return &(m_matrix->m_A_off_diagonal);}
 
private:
    SparseMatrixBuilder* m_matrix;
};
 
 
class TriDiagonalSolver: public PartialLinearSolver {
public:
    TriDiagonalSolver( SparseMatrixBuilder* matrix, int start, int end);
    //TriDiagonalSolver( SparseMatrixBuilder* matrix, std::vector<int> indices);
 
    ~TriDiagonalSolver();
    virtual void Compute();
 
    virtual void Solve( const Vector& B, Vector& X );
 
protected:
    int m_start;
    int m_end;
    int m_num;
    //std::vector<int> m_ix;
 
    mat6* m_U_1;
    mat6* m_U_0;
};
 
class SupergridSolver: public PartialLinearSolver {
public:
    SupergridSolver( SparseMatrixBuilder* matrix, int D);
    ~SupergridSolver();
    virtual void Compute();
 
    virtual void Solve( const Vector& B, Vector& X );
 
protected:
    int m_D;
    int m_num;
 
    mat6* m_A_1;
    mat6* m_A_0;
    std::vector<Eigen::SparseVector<mat6*> > m_A_off;
    ObjectFactoryStack<mat6> m_mat6_Factory;
 
    mat6* m_U_1;
    mat6* m_U_0;
 
    mat6* m_W_0;
    mat6* m_W_1;
 
    Eigen::SimplicialLDLT<SparseMat, Eigen::Upper>* m_solver;
};
 
 
}*/