• 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

localstiffness.hh

Go to the documentation of this file.

// $Id: localstiffness.hh 532 2008-12-28 10:41:20Z sander $

#ifndef DUNE_LOCALSTIFFNESS_HH
#define DUNE_LOCALSTIFFNESS_HH

#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<stdio.h>
#include<stdlib.h>

#include<dune/common/timer.hh>
#include<dune/common/fvector.hh>
#include<dune/common/fmatrix.hh>
#include<dune/common/fixedarray.hh>
#include<dune/common/exceptions.hh>
#include<dune/common/geometrytype.hh>
#include<dune/grid/common/grid.hh>
#include<dune/istl/operators.hh>
#include<dune/istl/bvector.hh>
#include<dune/istl/matrix.hh>
#include"boundaryconditions.hh"

namespace Dune
{
  template<class GV, class RT, int m>
  class LocalStiffness 
  {
        // grid types
      typedef typename GV::Grid::ctype DT;
      typedef typename GV::template Codim<0>::Entity Entity;
        enum {n=GV::dimension};

  public:
        // types for matrics, vectors and boundary conditions
        typedef FieldMatrix<RT,m,m> MBlockType;                      // one entry in the stiffness matrix
        typedef FieldVector<RT,m> VBlockType;                        // one entry in the global vectors
    typedef array<BoundaryConditions::Flags,m> BCBlockType; // componentwise boundary conditions

        virtual ~LocalStiffness () 
        {
        }


      virtual void assemble (const Entity& e, int k=1) = 0;

      virtual void assemble (const Entity& e, const BlockVector<VBlockType>& localSolution, int k=1) = 0;
    


      virtual void assembleBoundaryCondition (const Entity& e, int k=1) = 0;

        void print (std::ostream& s, int width, int precision)
        {
          // set the output format
          s.setf(std::ios_base::scientific, std::ios_base::floatfield);
          int oldprec = s.precision();
          s.precision(precision);

          for (int i=0; i<currentsize(); i++)
                {
                  s << "FEM";    // start a new row
                  s << " ";      // space in front of each entry
                  s.width(4);    // set width for counter
                  s << i;        // number of first entry in a line
                  for (int j=0; j<currentsize(); j++)
                        {
                          s << " ";         // space in front of each entry
                          s.width(width);   // set width for each entry anew
                          s << mat(i,j);     // yeah, the number !
                        }
                  s << " ";         // space in front of each entry
                  s.width(width);   // set width for each entry anew
                  s << rhs(i);
                  s << " ";         // space in front of each entry
                  s.width(width);   // set width for each entry anew
                  s << bc(i)[0];
                  s << std::endl;// start a new line
                }
          

          // reset the output format
          s.precision(oldprec);
          s.setf(std::ios_base::fixed, std::ios_base::floatfield);
        }


        const MBlockType& mat (int i, int j) const
        {
          return A[i][j];
        }



        const VBlockType& rhs (int i) const
        {
          return b[i];
        }


        const BCBlockType& bc (int i) const
        {
          return bctype[i];
        }

        void setcurrentsize (int s)
        {
          A.setSize(s,s);
          b.resize(s);
          bctype.resize(s);
        }

        int currentsize ()
        {
            return A.N();
        }

  protected:
        // assembled data
        Matrix<MBlockType> A;
        std::vector<VBlockType> b;
        std::vector<BCBlockType> bctype;
    
  };

  template<class GV, class RT, int m>
  class LinearLocalStiffness : public LocalStiffness<GV,RT,m>
  {
        // grid types
      typedef typename GV::Grid::ctype DT;
      typedef typename GV::template Codim<0>::Entity Entity;
        enum {n=GV::dimension};

  public:
        // types for matrics, vectors and boundary conditions
      typedef FieldMatrix<RT,m,m> MBlockType;                      // one entry in the stiffness matrix
      typedef FieldVector<RT,m> VBlockType;                        // one entry in the global vectors
      typedef array<BoundaryConditions::Flags,m> BCBlockType; // componentwise boundary conditions

      LinearLocalStiffness ()
      {}

      virtual ~LinearLocalStiffness () 
      {
      }


      virtual void assemble (const Entity& e, int k=1) = 0;

      virtual void assemble (const Entity& e, const BlockVector<VBlockType>& localSolution, int k=1)
      {
          assemble(e,k);
      }
    
  };

}
#endif

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