ISTLMatrix.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ISTL_MATRIX_H
#define _ISTL_MATRIX_H
 
#include "SparseMatrix.h"
#include "ISTLSolParams.h"
#include <memory>
 
class LinSolParams;
 
 
class ISTLVector : public StdVector
{
public:
  explicit ISTLVector(const ProcessAdm& padm);
  ISTLVector(const ProcessAdm& padm, size_t n);
  ISTLVector(const ProcessAdm& padm, const Real* values, size_t n);
  ISTLVector(const ISTLVector& vec);
  ~ISTLVector() override;
 
  LinAlg::MatrixType getType() const override { return LinAlg::ISTL; }
 
  void init(Real value = Real(0)) override;
 
  size_t dim() const override { return x.size(); }
 
  void redim(size_t n) override;
 
  bool endAssembly() override;
 
  Real L1norm() const override;
 
  Real L2norm() const override;
 
  Real Linfnorm() const override;
 
  const ProcessAdm& getAdm() const { return adm; }
 
  ISTL::Vec& getVector() { return x; }
  const ISTL::Vec& getVector() const { return x; }
 
protected:
  ISTL::Vec         x;   
  const ProcessAdm& adm; 
};
 
 
class ISTLMatrix : public SparseMatrix
{
public:
  ISTLMatrix(const ProcessAdm& padm, const LinSolParams& spar);
  ISTLMatrix(const ISTLMatrix& A);
  ~ISTLMatrix() override;
 
  LinAlg::MatrixType getType() const override { return LinAlg::ISTL; }
 
  size_t dim(int = 1) const override { return 0; }
 
  SystemMatrix* copy() const override { return new ISTLMatrix(*this); }
 
  void initAssembly(const SAM& sam, char) override;
 
  void init() override;
 
  bool endAssembly() override;
 
  bool solve(SystemVector& B, Real*) override;
 
  bool solve(const SystemVector& B, SystemVector& x) override;
 
  Real Linfnorm() const override;
 
  ISTL::Mat& getMatrix() { return iA; }
  const ISTL::Mat& getMatrix() const { return iA; }
 
protected:
  void handleSolverReset();
 
  std::unique_ptr<ISTL::Operator> op; 
  std::unique_ptr<ISTL::InverseOperator> solver; 
  std::unique_ptr<ISTL::Preconditioner> pre; 
 
  ISTL::Mat         iA;        
  const ProcessAdm& adm;       
  ISTLSolParams     solParams; 
  int               nLinSolves = 0; 
};
 
#endif