numerics/bvp.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_BVP_H
#define _MATHTL_BVP_H

#include <geometry/point.h>
#include <geometry/atlas.h>
#include <algebra/matrix.h>
#include <utils/array1d.h>
#include <utils/fixed_array1d.h>
#include <utils/function.h>

namespace MathTL
{
  template <unsigned int DIM>
  class TwoPointBVP
  {
  public:
    virtual ~TwoPointBVP();

    virtual void apply_A(const Point<DIM>& v, Point<DIM>& result) const = 0;
    
    virtual void apply_B(const Point<DIM>& v, Point<DIM>& result) const = 0;
    
    virtual void apply_f(const double t, const Point<DIM>& v, Point<DIM>& result) const = 0;
  };

  template <unsigned int DIM>
  class EllipticBVP
  {
  public:
    EllipticBVP(const Function<DIM>* a,
                const Function<DIM>* q,
                const Function<DIM>* f);

    virtual ~EllipticBVP() {}

    virtual const double a(const Point<DIM>& x) const
    {
      return a_->value(x);
    }

    virtual const double q(const Point<DIM>& x) const
    {
      return q_->value(x);
    }

    virtual const bool constant_coefficients() const = 0;
    
    virtual const double f(const Point<DIM>& x) const
    {
      return f_->value(x);
    }

    void set_f(const Function<DIM>* f);
    
  protected:
    const Function<DIM>* a_;

    const Function<DIM>* q_;
    
    const Function<DIM>* f_;
  };

  template <unsigned int DIM>
  class PoissonBVP
    : public EllipticBVP<DIM>
  {
  public:
    PoissonBVP(const Function<DIM>* f);

    const double a(const Point<DIM>& x) const { return 1.0; }

    const double q(const Point<DIM>& x) const { return 0.0; }

    const bool constant_coefficients() const { return true; }
  };

  template <unsigned int DIM>
  class IdentityBVP
    : public EllipticBVP<DIM>
  {
  public:
    IdentityBVP(const Function<DIM>* f);

    const double a(const Point<DIM>& x) const { return 0.0; }

    const double q(const Point<DIM>& x) const { return 1.0; }

    const bool constant_coefficients() const { return true; }
  };



   template <unsigned int DIM>
   class BiharmonicBVP
   {
  public:
    BiharmonicBVP(const Function<DIM>* f);

    virtual ~BiharmonicBVP() {}

    const bool constant_coefficients() const;
    
    const double f(const Point<DIM>& x) const
    {
      return f_->value(x);
    }

    void set_f(const Function<DIM>* f);
    
  protected:
    
    const Function<DIM>* f_;
  };


}

#include <numerics/bvp.cpp>

#endif