• Home
• About DUNE
  • What is DUNE
  • News
  • Gallery
  • Publications
• Download
  • Core Modules (Stable)
    • Release Notes (v1.1)
    • Release Notes (v1.0)
  • Recent Changes
  • External Modules
  • Dune Logo
• Documentation
  • Installation
  • Using DUNE
  • Class Documentation
• Community
  • People
  • Mailinglists
  • FAQ
• Development
  • Developing DUNE
  • Unstable Modules
    • Download via SVN
    • Class Documentation
  • Bug Tracking System
  • Automated Test Environment

cubeshapefunctions.hh

Go to the documentation of this file.

// $Id: cubeshapefunctions.hh 336 2006-05-03 13:09:05Z oliver $

#ifndef DUNE_CUBESHAPEFUNCTIONS_HH
#define DUNE_CUBESHAPEFUNCTIONS_HH

#include<iostream>
#include<dune/common/fvector.hh>
#include<dune/common/exceptions.hh>
#include<dune/common/misc.hh>
#include<dune/common/geometrytype.hh>
#include<dune/grid/common/referenceelements.hh>

namespace Dune
{
  /***********************************************************
   * P0 shape functions for the cube
   ***********************************************************/


  template<typename C, typename T, int d>
  class P0CubeShapeFunction
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=1 }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef P0CubeShapeFunction ImplementationType;

        P0CubeShapeFunction ()
        {
          for (int j=0; j<dim; j++)
                pos[j] = 0.5;
        }

        ResultType evaluateFunction (int comp, const FieldVector<CoordType,d>& x) const
        {
          return 1;
        }

        ResultType evaluateDerivative (int comp, int dir, const FieldVector<CoordType,d>& x) const
        {
          return 0;
        }

        int localindex (int comp) const
        {
          return 0;
        }

        int codim () const
        {
          return 0;
        }

        int entity () const
        {
          return 0;
        }

        int entityindex () const
        {
          return 0;
        }

        const FieldVector<CoordType,dim>& position () const
        {
          return pos;
        }
        
  private:
        FieldVector<CoordType,d> pos;
  };


  template<typename C, typename T, int d, typename S>
  class P0CubeShapeFunctionSet
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=1 }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef S value_type;
        typedef typename S::ImplementationType Imp; // Imp is either S or derived from S

        P0CubeShapeFunctionSet ()
        {
          sf = Imp(); // assignment of derived class objects defined in wrapper
        }

        int size () const
        {
          return 1;
        }

        int size (int entity, int codim) const
        {
          if (codim==0) return 1; else return 0;
        }
        
        const value_type& operator[] (int i) const
        {
          return sf; // ok derived class reference goes for base class reference
        }

        int order () const
        {
          return 0;
        }

        GeometryType type () const
        {
      static GeometryType cube(GeometryType::cube, dim);
          return cube;
        }

  private:
        S sf;
  };



  template<typename C, typename T, int d>
  class P0CubeShapeFunctionSetContainer
  {
  public:
        // compile time sizes
        enum { dim=d };       
        enum { comps=1 };
        enum { maxsize=1 };

        // exported types
        typedef C CoordType; 
        typedef T ResultType;
        typedef P0CubeShapeFunctionSet<C,T,d,P0CubeShapeFunction<C,T,d> > value_type;

        const value_type& operator() (GeometryType type, int order) const
        {
      if (type.isCube()) return p0cube;
          DUNE_THROW(NotImplemented, "type not implemented yet");
        }
  private:
        value_type p0cube;
  };
 


  /***********************************************************
   * P1 shape functions for the cube of any dimension
   * The basic classes implement the interface of a 
   * LagrangeShapeFunction(Set) but are NOT derived from
   * it. They can be used in simple cases (fixed element type and
   * order) to avoid virtual function calls. The generally usable
   * classes are then wrapped up with the Wrappers to supply
   * the virtual functions of the abstract interface.
   ***********************************************************/

  template<typename C, typename T, int d>
  class P1CubeShapeFunction
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=1<<dim }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef P1CubeShapeFunction ImplementationType;

        P1CubeShapeFunction (int i) // make it the i'th shape function
        {
          number = i;
          //std::cout<<"number="<<number;
          for (int j=0; j<dim; j++)
                {
                  a[j] = 1 - ((i>>j)&1);
                  b[j] = 2*((i>>j)&1) - 1;
                  pos[j] = (i>>j)&1;
                }
        }

        P1CubeShapeFunction ()
    {}

        ResultType evaluateFunction (int comp, const FieldVector<CoordType,d>& x) const
        {
          ResultType phi = a[0]+x[0]*b[0];
          for (int j=1; j<dim; j++) phi *= a[j]+x[j]*b[j];
          return phi;
        }

        ResultType evaluateDerivative (int comp, int dir, const FieldVector<CoordType,d>& x) const
        {
          ResultType deriv = b[dir];
          for (int j=0; j<dim; j++)
                if (j!=dir) deriv *= a[j]+x[j]*b[j];
          return deriv;
        }

        int localindex (int comp) const
        {
          return number;
        }

        int codim () const
        {
          return dim;
        }

        int entity () const
        {
          return number;
        }

        int entityindex () const
        {
          return 0;
        }

        const FieldVector<CoordType,dim>& position () const
        {
          return pos;
        }
        
  private:
        int number;
        ResultType a[dim], b[dim]; // store coefficients for this shape function
        FieldVector<CoordType,d> pos;
  };


  template<typename C, typename T, int d, typename S>
  class P1CubeShapeFunctionSet
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=1<<dim }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef S value_type;
        typedef typename S::ImplementationType Imp; // Imp is either S or derived from S

        P1CubeShapeFunctionSet ()
        {
          for (int i=0; i<m; i++)
                sf[i] = Imp(i); // assignment of derived class objects defined in wrapper
        }

        int size () const
        {
          return m;
        }

        int size (int entity, int codim) const
        {
          if (codim==dim) return 1; else return 0;
        }
        
        const value_type& operator[] (int i) const
        {
          return sf[i]; // ok derived class reference goes for base class reference
        }

        int order () const
        {
          return 1;
        }

        GeometryType type () const
        {
      static GeometryType cube(GeometryType::cube, dim);
          return cube;
        }

  private:
        S sf[m];
  };



  template<typename C, typename T, int d>
  class P1CubeShapeFunctionSetContainer
  {
  public:
        // compile time sizes
        enum { dim=d };       
        enum { comps=1 };
        enum { maxsize=1<<dim };

        // exported types
        typedef C CoordType; 
        typedef T ResultType;
        typedef P1CubeShapeFunctionSet<C,T,d,P1CubeShapeFunction<C,T,d> > value_type;

        const value_type& operator() (GeometryType type, int order) const
        {
      if (type.isCube()) return p1cube;
          DUNE_THROW(NotImplemented, "type not implemented yet");
        }
  private:
        value_type p1cube;
  };
 



  /***********************************************************
   * P2 shape functions for the cube of any dimension
   ***********************************************************/

  template<typename C, typename T, int d>
  class P2CubeShapeFunction
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=Power_m_p<3,d>::power }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef P2CubeShapeFunction ImplementationType;

        P2CubeShapeFunction (int no, int en, int co, const FieldVector<int,dim>& ipos) // make it the i'th shape function
        {
          num = no;
          ent = en;
          cod = co;
          for (int j=0; j<dim; j++)
                {
                  if (ipos[j]==0)
                        {
                          a[j] = 1.0; 
                          b[j] = -3.0;
                          c[j] = 2.0;
                          pos[j] = 0;
                        }
                  if (ipos[j]==1)
                        {
                          a[j] = 0.0; 
                          b[j] = 4.0;
                          c[j] = -4.0;
                          pos[j] = 0.5;
                        }
                  if (ipos[j]==2)
                        {
                          a[j] = 0.0; 
                          b[j] = -1.0;
                          c[j] = 2.0;
                          pos[j] = 1.0;
                        }
                }
        }

        P2CubeShapeFunction ()
        {       }

        ResultType evaluateFunction (int comp, const FieldVector<CoordType,d>& x) const
        {
          ResultType phi = a[0]+x[0]*b[0] +x[0]*x[0]*c[0];
          for (int j=1; j<dim; j++) phi *= a[j]+x[j]*b[j]+x[j]*x[j]*c[j];
          return phi;
        }

        ResultType evaluateDerivative (int comp, int dir, const FieldVector<CoordType,d>& x) const
        {
          ResultType deriv = b[dir]+2*c[dir]*x[dir];
          for (int j=0; j<dim; j++)
                if (j!=dir) deriv *= a[j]+x[j]*b[j]+x[j]*x[j]*c[j];
          return deriv;
        }

        int localindex (int comp) const
        {
          return num;
        }

        int codim () const
        {
          return cod;
        }

        int entity () const
        {
          return ent;
        }

        int entityindex () const
        {
          return 0;
        }

        const FieldVector<CoordType,dim>& position () const
        {
          return pos;
        }
        
  private:
        int num;
        int ent;
        int cod;
        ResultType a[dim], b[dim], c[dim]; // store coefficients for this shape function
        FieldVector<CoordType,d> pos;
  };


  template<typename C, typename T, int d, typename S>
  class P2CubeShapeFunctionSet
  {
  public:

        // compile time sizes
        enum { dim=d };    // maps from R^d
        enum { comps=1 };      // to R^1

        enum { m=Power_m_p<3,d>::power }; // total number of basis functions

        // export types
        typedef C CoordType;
        typedef T ResultType;
        typedef S value_type;
        typedef typename S::ImplementationType Imp; // Imp is either S or derived from S

        P2CubeShapeFunctionSet ()
        {
          ReferenceCube<C,d> cube;
          int i=0;
          for (int c=0; c<=dim; c++)
                for (int e=0; e<cube.size(c); e++)
                  {
                        sf[i] = Imp(i,e,c,cube.iposition(e,c));
                        i++;
                  }
        }

        int size () const
        {
          return m;
        }

        int size (int entity, int codim) const
        {
          return 1;
        }
        
        const value_type& operator[] (int i) const
        {
          return sf[i]; // ok derived class reference goes for base class reference
        }

        int order () const
        {
          return 2;
        }

        GeometryType type () const
        {
      static GeometryType cube(GeometryType::cube, dim);
          return cube;
        }

  private:
        S sf[m];
  };


  template<typename C, typename T, int d>
  class P2CubeShapeFunctionSetContainer
  {
  public:
        // compile time sizes
        enum { dim=d };       
        enum { comps=1 };
        enum { maxsize=Power_m_p<3,d>::power };

        // exported types
        typedef C CoordType; 
        typedef T ResultType;
        typedef P2CubeShapeFunctionSet<C,T,d,P2CubeShapeFunction<C,T,d> > value_type;

        const value_type& operator() (GeometryType type, int order) const
        {
      if (type.isCube()) return p2cube;
          DUNE_THROW(NotImplemented, "type not implemented yet");
        }
  private:
        value_type p2cube;
  };
 


}
#endif

Generated on 6 Jan 2009 with Doxygen (ver 1.5.1) [logfile].