← Back to branch summary

~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to src/kernel/la/GMRES.cpp

  • Committer: Anders Logg
  • Date: 2007-01-10 09:04:44 UTC
  • mfrom: (1689.1.221 trunk)
  • Revision ID: logg@simula.no-20070110090444-ecyux3n1qnei4i8h
Remove old head

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kernel/la/GMRES.cpp
1
 
// Copyright (C) 2005 Garth N. Wells.
 
1
// Copyright (C) 2006 Anders Logg.
2
2
// Licensed under the GNU GPL Version 2.
3
 
//
4
 
// First added:  2005-12-02
5
 
// Last changed:
 
3
// 
 
4
// First added:  2006-08-16
 
5
// Last changed: 2006-08-16
6
6
 
7
7
#include <dolfin/GMRES.h>
8
8
 
9
9
using namespace dolfin;
10
10
 
11
 
//-----------------------------------------------------------------------------
12
 
GMRES::GMRES() : KrylovSolver(gmres)
13
 
{
14
 
  // Do nothing.
15
 
}
16
 
//-----------------------------------------------------------------------------
17
 
GMRES::GMRES(Preconditioner::Type preconditioner_type) : KrylovSolver(gmres, preconditioner_type)
18
 
{
19
 
  // Do nothing.
20
 
}
21
 
//-----------------------------------------------------------------------------
22
 
GMRES::~GMRES()
23
 
{
24
 
  // Do nothing.
 
11
#ifdef HAVE_PETSC_H
 
12
//-----------------------------------------------------------------------------
 
13
dolfin::uint GMRES::solve(const PETScMatrix& A, PETScVector& x,
 
14
                          const PETScVector& b, Preconditioner pc)
 
15
{
 
16
  PETScKrylovSolver solver(gmres, pc);
 
17
  return solver.solve(A, x, b);
 
18
}
 
19
//-----------------------------------------------------------------------------
 
20
dolfin::uint GMRES::solve(const PETScKrylovMatrix& A, PETScVector& x,
 
21
                          const PETScVector& b, Preconditioner pc)
 
22
{
 
23
  PETScKrylovSolver solver(gmres, pc);
 
24
  return solver.solve(A, x, b);
 
25
}
 
26
//-----------------------------------------------------------------------------
 
27
dolfin::uint GMRES::solve(const PETScMatrix& A, PETScVector& x,
 
28
                          const PETScVector& b, PETScPreconditioner& pc)
 
29
{
 
30
  PETScKrylovSolver solver(gmres, pc);
 
31
  return solver.solve(A, x, b);
 
32
}
 
33
//-----------------------------------------------------------------------------
 
34
dolfin::uint GMRES::solve(const PETScKrylovMatrix& A, PETScVector& x,
 
35
                          const PETScVector& b, PETScPreconditioner& pc)
 
36
{
 
37
  PETScKrylovSolver solver(gmres, pc);
 
38
  return solver.solve(A, x, b);
 
39
}
 
40
//-----------------------------------------------------------------------------
 
41
#endif
 
42
 
 
43
//-----------------------------------------------------------------------------
 
44
dolfin::uint GMRES::solve(const uBlasMatrix<ublas_dense_matrix>& A,
 
45
                          uBlasVector& x, const uBlasVector& b,
 
46
                          Preconditioner pc)
 
47
{
 
48
  uBlasKrylovSolver solver(gmres, pc);
 
49
  return solver.solve(A, x, b);
 
50
}
 
51
//-----------------------------------------------------------------------------
 
52
dolfin::uint GMRES::solve(const uBlasMatrix<ublas_sparse_matrix>& A,
 
53
                          uBlasVector& x, const uBlasVector& b,
 
54
                          Preconditioner pc)
 
55
{
 
56
  uBlasKrylovSolver solver(gmres, pc);
 
57
  return solver.solve(A, x, b);
 
58
}
 
59
//-----------------------------------------------------------------------------
 
60
dolfin::uint GMRES::solve(const uBlasKrylovMatrix& A, uBlasVector& x,
 
61
                          const uBlasVector& b, Preconditioner pc)
 
62
{
 
63
  uBlasKrylovSolver solver(gmres, pc);
 
64
  return solver.solve(A, x, b);
 
65
}
 
66
//-----------------------------------------------------------------------------
 
67
dolfin::uint GMRES::solve(const uBlasMatrix<ublas_dense_matrix>& A,
 
68
                          uBlasVector& x, const uBlasVector& b,
 
69
                          uBlasPreconditioner& pc)
 
70
{
 
71
  uBlasKrylovSolver solver(gmres, pc);
 
72
  return solver.solve(A, x, b);
 
73
}
 
74
//-----------------------------------------------------------------------------
 
75
dolfin::uint GMRES::solve(const uBlasMatrix<ublas_sparse_matrix>& A,
 
76
                          uBlasVector& x, const uBlasVector& b,
 
77
                          uBlasPreconditioner& pc)
 
78
{
 
79
  uBlasKrylovSolver solver(gmres, pc);
 
80
  return solver.solve(A, x, b);
 
81
}
 
82
//-----------------------------------------------------------------------------
 
83
dolfin::uint GMRES::solve(const uBlasKrylovMatrix& A, uBlasVector& x,
 
84
                          const uBlasVector& b, uBlasPreconditioner& pc)
 
85
{
 
86
  uBlasKrylovSolver solver(gmres, pc);
 
87
  return solver.solve(A, x, b);
25
88
}
26
89
//-----------------------------------------------------------------------------