Discretization.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: Discretization.hpp,v 1.8 2008/03/30 20:24:24 delpinux Exp $

#ifndef DISCRETIZATION_HPP
#define DISCRETIZATION_HPP

#include <ReferenceCounting.hpp>

#include <BaseVector.hpp>
#include <Vector.hpp>
#include <BaseMatrix.hpp>

#include <Problem.hpp>

#include <DiscretizationType.hpp>

class Discretization
{
protected:
  const DiscretizationType __discretizationType; 

  const Problem& __problem;

  BaseMatrix& __A;

  BaseVector& __b;

  const Vector<bool>* __dirichletList;

public:
  void setDirichletList(const Vector<bool>& dirichletList)
  {
    ASSERT(__dirichletList == 0);
    __dirichletList = &dirichletList;
  }

  virtual void assembleMatrix() = 0;

  virtual void assembleSecondMember() = 0;

  virtual void getDiagonal(BaseVector& u) const = 0;

  virtual void transposedTimesX(const BaseVector& x, BaseVector& v) const = 0;

  virtual void timesX(const BaseVector& x, BaseVector& v) const = 0;

  const Problem& problem() const
  {
    return __problem;
  }

//   /** 
//    * Read only access to the discretization type
//    * 
//    * @return __type
//    */
//   const Discretization::Type&
//   type() const
//   {
//     return __type;
//   }

  BaseMatrix& A()
  {
    return __A;
  }

  BaseVector& b()
  {
    return __b;
  }

  Discretization(const DiscretizationType& discretizationType,
                 const Problem& problem,
                 BaseMatrix& A,
                 BaseVector& b)
    : __discretizationType(discretizationType),
      __problem(problem),
      __A(A),
      __b(b),
      __dirichletList(0)
  {
    ;
  }

  Discretization(const Discretization& d)
    : __discretizationType(d.__discretizationType),
      __problem(d.__problem),
      __A(d.__A),
      __b(d.__b),
      __dirichletList(0)
  {
    ;
  }

  virtual ~Discretization()
  {
    ;
  }
};

#endif // DISCRETIZATION_HPP

---