linearsystem.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2012 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef LINEARSYSTEM_HH
#define LINEARSYSTEM_HH
 
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
 
#include "linalg/triplet.hh"
 
namespace Kaskade 
{
class SparseLinearSystem
{
public:
  virtual void getMatrix(MatrixAsTriplet<double>& mat) const { getMatrixBlocks(mat,0,nRowBlocks(),0,nColBlocks());}
 
  virtual void  getRHS(std::vector<double>& rhs) const { getRHSBlocks(rhs,0,nRowBlocks()); }
 
  virtual int size() const {return cols(0,nColBlocks());};
 
  virtual int rows(int rbegin, int rend) const = 0;
  virtual int cols(int colbegin, int colend) const = 0;
 
  virtual void getMatrixBlocks(MatrixAsTriplet<double>& mat, int rbegin, int rend, int colbegin, int colend) const = 0;
 
  virtual double getValue() const = 0;
 
  virtual void getRHSBlocks(std::vector<double>& rhs, int rbegin, int rend) const = 0;
 
  virtual int nColBlocks() const = 0;
 
  virtual int nRowBlocks() const = 0;
 
  virtual ~SparseLinearSystem() {};
};
 
class SimpleSparseLinearSystem : public SparseLinearSystem
{
public:
  SimpleSparseLinearSystem(std::vector<int>const& ridx, std::vector<int>const& cidx, std::vector<double>const& data, std::vector<double>const& rhs_)
  {
    mat.ridx = ridx;
    mat.cidx = cidx;
    mat.data = data;
    rhs = rhs_;
  }
 
  virtual void getMatrixBlocks(MatrixAsTriplet<double>& mat_, int rbegin, int rend, int colbegin, int colend) 
    const {mat_=mat;}
  virtual void getRHSBlocks(std::vector<double>& rhs_, int rbegin, int rend) const { rhs_=rhs;}
  virtual int  cols(int colbegin, int colend) const {return mat.ncols(); }
  virtual int  rows(int rowbegin, int rowend) const {return mat.nrows(); }
  
  virtual double getValue() const {return 0;}
 
  virtual int nColBlocks() const {return 1;}
  virtual int nRowBlocks() const {return 1;}
 
private:
  MatrixAsTriplet<double> mat;
  std::vector<double> rhs;
};
 
namespace Bridge {
 
  class UnknownLinearization;
 
  template<class Vector, class Functional>
  class LinearizationTraits
  {
  public:
    typedef UnknownLinearization Linearization;
  };
}
} // end of namespace Kaskade
 
#endif