← Back to branch summary

~ubuntu-branches/debian/squeeze/gmsh/squeeze

« back to all changes in this revision

Viewing changes to Solver/linearSystemGMM.h

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme, Christophe Prud'homme
  • Date: 2009-09-27 17:36:40 UTC
  • mfrom: (1.4.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090927173640-meoeywl4f5hq5qas
Tags: 2.4.2.dfsg-1
[Christophe Prud'homme]
* New upstream release
  + solver code refactoring
  + better IDE integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Solver/linearSystemGMM.h
 
1
// Gmsh - Copyright (C) 1997-2009 C. Geuzaine, J.-F. Remacle
 
2
//
 
3
// See the LICENSE.txt file for license information. Please report all
 
4
// bugs and problems to <gmsh@geuz.org>.
 
5
 
 
6
#ifndef _LINEAR_SYSTEM_GMM_H_
 
7
#define _LINEAR_SYSTEM_GMM_H_
 
8
 
 
9
// Interface to GMM++
 
10
 
 
11
#include "GmshConfig.h"
 
12
#include "GmshMessage.h"
 
13
#include "linearSystem.h"
 
14
 
 
15
#if defined(HAVE_GMM)
 
16
#include <gmm.h>
 
17
 
 
18
template <class scalar>
 
19
class linearSystemGmm : public linearSystem<scalar> {
 
20
 private:
 
21
  gmm::row_matrix<gmm::wsvector<scalar> > *_a;
 
22
  std::vector<scalar> *_b, *_x;
 
23
  double _prec;
 
24
  int _noisy, _gmres;
 
25
 public:
 
26
  linearSystemGmm()
 
27
    : _a(0), _b(0), _x(0), _prec(1.e-8), _noisy(0), _gmres(0) {}
 
28
  virtual bool isAllocated() const { return _a != 0; }
 
29
  virtual void allocate(int _nbRows)
 
30
  {
 
31
    clear();
 
32
    _a = new gmm::row_matrix< gmm::wsvector<scalar> >(_nbRows, _nbRows);
 
33
    _b = new std::vector<scalar>(_nbRows);
 
34
    _x = new std::vector<scalar>(_nbRows);
 
35
  }
 
36
  virtual ~linearSystemGmm()
 
37
  {
 
38
    clear();
 
39
  }
 
40
  virtual void clear()
 
41
  {
 
42
    if (_a){
 
43
      delete _a;
 
44
      delete _b;
 
45
      delete _x;
 
46
    }
 
47
    _a = 0;
 
48
  }
 
49
  virtual void  addToMatrix(int _row, int _col, scalar _val) 
 
50
  {
 
51
    if(_val != 0.0) (*_a)(_row, _col) += _val;
 
52
  }
 
53
  virtual scalar getFromMatrix (int _row, int _col) const
 
54
  {
 
55
    return (*_a)(_row, _col);
 
56
  }
 
57
  virtual void addToRightHandSide(int _row, scalar _val) 
 
58
  {
 
59
    if(_val != 0.0) (*_b)[_row] += _val;
 
60
  }
 
61
  virtual scalar getFromRightHandSide(int _row) const 
 
62
  {
 
63
    return (*_b)[_row];
 
64
  }
 
65
  virtual scalar getFromSolution(int _row) const
 
66
  {
 
67
    return (*_x)[_row];
 
68
  }
 
69
  virtual void zeroMatrix()
 
70
  {
 
71
    gmm::clear(*_a);
 
72
  }
 
73
  virtual void zeroRightHandSide() 
 
74
  {
 
75
    for(unsigned int i = 0; i < _b->size(); i++) (*_b)[i] = 0.;
 
76
  }
 
77
  void setPrec(double p){ _prec = p; }
 
78
  void setNoisy(int n){ _noisy = n; }
 
79
  void setGmres(int n){ _gmres = n; }
 
80
  virtual int systemSolve() 
 
81
  {
 
82
    //gmm::ilutp_precond<gmm::row_matrix<gmm::wsvector<scalar> > > P(*_a, 25, 0.);
 
83
    gmm::ildltt_precond<gmm::row_matrix<gmm::wsvector<scalar> > > P(*_a, 30, 1.e-10);
 
84
    gmm::iteration iter(_prec);
 
85
    iter.set_noisy(_noisy);
 
86
    if(_gmres) gmm::gmres(*_a, *_x, *_b, P, 100, iter);
 
87
    else gmm::cg(*_a, *_x, *_b, P, iter);
 
88
    return 1;
 
89
  }
 
90
};
 
91
 
 
92
#else
 
93
 
 
94
template <class scalar>
 
95
class linearSystemGmm : public linearSystem<scalar> {
 
96
 public :
 
97
  linearSystemGmm()
 
98
  {
 
99
    Msg::Error("Gmm++ is not available in this version of Gmsh");
 
100
  }
 
101
  virtual bool isAllocated() const { return false; }
 
102
  virtual void allocate(int nbRows) {}
 
103
  virtual void addToMatrix(int _row, int _col, scalar val) {}
 
104
  virtual scalar getFromMatrix(int _row, int _col) const { return 0.; }
 
105
  virtual void addToRightHandSide(int _row, scalar val) {}
 
106
  virtual scalar getFromRightHandSide(int _row) const { return 0.; }
 
107
  virtual scalar getFromSolution(int _row) const { return 0.; }
 
108
  virtual void zeroMatrix() {}
 
109
  virtual void zeroRightHandSide() {}
 
110
  virtual int systemSolve() { return 0; }
 
111
  void setPrec(double p){}
 
112
  virtual void clear(){}
 
113
  void setNoisy(int n){}
 
114
  void setGmres(int n){}
 
115
}; 
 
116
 
 
117
#endif
 
118
 
 
119
#endif