supermatrix_superLU.hpp

#ifndef SUPER_SUPER_LU_HPP
#define SUPER_SUPER_LU_HPP

#include "supermatrix.hpp"

#ifdef USE_SUPERLU_DIST    
#   include "superlu_zdefs.h"
#else
#   include "slu_zdefs.h"
#endif

/*-----------------*
 * BAKED STRATEGY  *
 *-----------------*/

class super_Matrix_Baked: public super_Matrix_strategy{
    std::unique_ptr<SuperMatrix> A;

    NCformat* Astore(){ 
    return reinterpret_cast<NCformat*>(A->Store);};
    NCformat const * Astore() const{ 
    return reinterpret_cast<NCformat*>(A->Store);};

public:

    super_Matrix_Baked(super_Matrix* m,
               std::unique_ptr<SuperMatrix> a);
    ~super_Matrix_Baked();

    void Insert(row, column, complex){
    fail("Insert not valid in Baked Phase!\n");};
    void Add(row, column, complex);
    complex Get(row, column) const;

    void Apply(const complex*, 
                     complex*) const;
    void Apply(      complex*) const;
    void Output(std::ostream& os) const;

    status my_status() const{return Baked;};

    std::unique_ptr<SuperMatrix> release(){ return A;};
};

class super_Matrix_SetUp;
class matrix_factory{
public:
    static std::unique_ptr<SuperMatrix> get(const super_Matrix_SetUp&);
};

#ifdef USE_SUPERLU_DIST

/*--------------------------*
 * DIST FACTORIZED STRATEGY *
 *--------------------------*/

class super_Matrix_Factorized: public super_Matrix_strategy{

    std::unique_ptr<int> perm_c;
    std::unique_ptr<int> perm_r;
  std::unique_ptr<SuperMatrix> A;


    superlu_options_t options;
  LUstruct_t LU;
  gridinfo_t grid;
  ScalePermstruct_t ScalePermstruct;
  double *berr;
  doublecomplex *b;
  int ldb;
    
   
public:
  // the second parameter is the superlu supermatrix 

    super_Matrix_Factorized( super_Matrix*, 
                  std::unique_ptr<SuperMatrix>);
    ~super_Matrix_Factorized();

    void Insert(row, column, complex){
    fail("Insert not valid in Factorized dist Phase!\n");};
    void Add(row, column, complex){
    fail("Add not valid in Factorized dist Phase!\n");};
    complex Get(row, column) const{
    fail("Get not valid in Factorized dist Phase!\n"); return complex(0.,0.);};

    void Apply(const complex* phi, 
                     complex* result) const;
    void Apply(      complex* result) const;
    void Output(std::ostream& os) const {
    fail("Output not valid in Factorized dist Phase!\n");};

    status my_status() const{return Factorized_dist;};
};

#else

/*----------------------*
 * FACTORIZED STRATEGY  *
 *----------------------*/

class super_Matrix_Factorized: public super_Matrix_strategy{

    std::unique_ptr<SuperMatrix> L;
    std::unique_ptr<SuperMatrix> U;
    std::unique_ptr<int> perm_c;
    std::unique_ptr<int> perm_r;

    superlu_options_t options;
    SuperLUStat_t stat;                   

   
public:
    super_Matrix_Factorized( super_Matrix*, 
                 std::unique_ptr<SuperMatrix>);
    ~super_Matrix_Factorized();

    void Insert(row, column, complex){
    fail("Insert not valid in Factorized Phase!\n");};
    void Add(row, column, complex){
    fail("Add not valid in Factorized Phase!\n");};
    complex Get(row, column) const{
    fail("Get not valid in Factorized Phase!\n"); return complex(0.,0.);};

    void Apply(const complex* phi, 
                     complex* result) const;
    void Apply(      complex* result) const;
    void Output(std::ostream& os) const {
    fail("Output not valid in Factorized Phase!\n");};

    status my_status() const{return Factorized;};
};

#endif 
#endif