b2sparse_solver.H

//------------------------------------------------------------------------
// b2sparse_solver.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2016
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef _B2SPARSE_SOLVER_H_
#define _B2SPARSE_SOLVER_H_
 
#include <cstddef>
 
#include "utils/b2dictionary.H"
#include "utils/b2util.H"
 
namespace b2000 { namespace b2linalg {
 
extern const char SingularMatrixError_name[];
class SingularMatrixError : public GenericException<SingularMatrixError_name> {
public:
    template <typename T>
    SingularMatrixError& operator<<(const T& t) {
        Exception::operator<<(t);
        return *this;
    }
 
    SingularMatrixError& operator<<(const Throw& t) {
        set_location(t);
        throw *this;
        return *this;
    }
 
    size_t null_space_size;
    std::vector<size_t> singular_dofs;
};
 
template <typename T>
class LDLt_sparse_solver {
public:
    virtual ~LDLt_sparse_solver() {}
 
    virtual void init(
          size_t s, size_t nnz, const size_t* colind, const size_t* rowind, const T* value,
          const int connectivity, const Dictionary& dictionary) = 0;
 
    virtual void update_value() = 0;
 
    virtual void resolve(
          size_t s, size_t nrhs, const T* b, size_t ldb, T* x, size_t ldx,
          char left_or_right = ' ') = 0;
 
    virtual size_t get_null_space_size() { return 0; }
 
    virtual void get_null_space(size_t s, size_t nv, T* m, size_t lm) {
        UnimplementedError() << THROW;
    }
 
    static LDLt_sparse_solver* new_default(const int connectivity, const Dictionary& dictionary);
};
 
template <typename T>
class LDLt_extension_sparse_solver {
public:
    virtual ~LDLt_extension_sparse_solver() {}
 
    virtual void init(
          size_t s, size_t nnz, const size_t* colind, const size_t* rowind, const T* value,
          size_t s_ext, const int connectivity, const Dictionary& dictionary) = 0;
 
    virtual void update_value() = 0;
 
    virtual void resolve(
          size_t s, size_t nrhs, const T* b, size_t ldb, T* x, size_t ldx, const T* ma = 0,
          const T* mb = 0, const T* mc = 0, char left_or_right = ' ') = 0;
 
    virtual size_t get_null_space_size() { return 0; }
 
    virtual void get_null_space(size_t s, size_t nv, T* m, size_t lm) {
        UnimplementedError() << THROW;
    }
 
    static LDLt_extension_sparse_solver* new_default(
          const int connectivity, const Dictionary& dictionary);
};
 
template <typename T>
class LU_sparse_solver {
public:
    virtual ~LU_sparse_solver() {}
 
    virtual void init(
          size_t s, size_t nnz, const size_t* colind, const size_t* rowind, const T* value,
          const int connectivity, const Dictionary& dictionary) = 0;
 
    virtual void update_value() = 0;
 
    virtual void resolve(
          size_t s, size_t nrhs, const T* b, size_t ldb, T* x, size_t ldx,
          char left_or_right = ' ') = 0;
 
    virtual size_t get_null_space_size() { return 0; }
 
    virtual void get_null_space(size_t s, size_t nv, const T* m, size_t lm) {
        UnimplementedError() << THROW;
    }
 
    static LU_sparse_solver* new_default(const int connectivity, const Dictionary& dictionary);
};
 
template <typename T>
class LU_extension_sparse_solver {
public:
    virtual ~LU_extension_sparse_solver() {}
 
    virtual void init(
          size_t s, size_t nnz, const size_t* colind, const size_t* rowind, const T* value,
          size_t s_ext, const int connectivity, const Dictionary& dictionary) = 0;
 
    virtual void update_value() = 0;
 
    virtual void resolve(
          size_t s, size_t nrhs, const T* b, size_t ldb, T* x, size_t ldx, const T* ma = 0,
          const T* mb = 0, const T* mc = 0, char left_or_right = ' ') = 0;
 
    virtual size_t get_null_space_size() { return 0; }
 
    virtual void get_null_space(size_t s, size_t nv, const T* m, size_t lm) {
        UnimplementedError() << THROW;
    }
 
    static LU_extension_sparse_solver* new_default(
          const int connectivity, const Dictionary& dictionary);
};
 
}}  // namespace b2000::b2linalg
 
#include "b2sparse_solver.inl"
 
#endif