linearelasticityparameter.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil -*-
#ifndef DUNE_PDELAB_LOCALOPERATOR_LINEARELASTICITYPARAMETER_HH
#define DUNE_PDELAB_LOCALOPERATOR_LINEARELASTICITYPARAMETER_HH
 
#include<vector>
 
#include<dune/common/exceptions.hh>
#include<dune/common/fvector.hh>
#include<dune/geometry/type.hh>
#include<dune/geometry/referenceelements.hh>
#include<dune/geometry/quadraturerules.hh>
#include<dune/pdelab/common/geometrywrapper.hh>
#include<dune/pdelab/common/function.hh>
#include<dune/pdelab/common/functionutilities.hh>
#include<dune/pdelab/constraints/common/constraintsparameters.hh>
 
namespace Dune {
  namespace PDELab {
 
    template<typename GV, typename RF>
    struct LinearElasticityParameterTraits
    {
      typedef GV GridViewType;
 
      enum {
        dimDomain = GV::dimension,
        dimRange = GV::dimension
      };
 
      typedef typename GV::Grid::ctype DomainFieldType;
 
      typedef Dune::FieldVector<DomainFieldType,dimDomain> DomainType;
 
      typedef Dune::FieldVector<DomainFieldType,dimDomain-1> IntersectionDomainType;
 
      typedef RF RangeFieldType;
 
      typedef Dune::FieldVector<RF,dimRange> RangeType;
 
      typedef typename GV::Traits::template Codim<0>::Entity ElementType;
      typedef typename GV::Intersection IntersectionType;
    };
 
    template<class T, class Imp>
    class LinearElasticityParameterInterface
      : public Dune::PDELab::DirichletConstraintsParameters
    {
    public:
      typedef T Traits;
 
      void
      f (const typename Traits::ElementType& e, const typename Traits::DomainType& x,
         typename Traits::RangeType & y) const
      {
        asImp().f(e,x,y);
      }
 
      template<typename I>
      bool isDirichlet(const I & ig,
        const typename Traits::IntersectionDomainType & coord
        ) const
      {
        return asImp().isDirichlet( ig, coord );
      }
 
      void
      u (const typename Traits::ElementType& e, const typename Traits::DomainType& x,
        typename Traits::RangeType & y) const
      {
        asImp().g(e,x,y);
      }
 
      // //! Neumann boundary condition (surface force)
      // void
      // g (const typename Traits::ElementType& e, const typename Traits::DomainType& x,
      //   typename Traits::RangeType & y) const
      // {
      //   asImp().g(e,x,y);
      // }
 
      typename Traits::RangeFieldType
      lambda(const typename Traits::ElementType& e, const typename Traits::DomainType& x) const
      {
        return asImp().lambda(e,x);
      }
 
      typename Traits::RangeFieldType
      mu(const typename Traits::ElementType& e, const typename Traits::DomainType& x) const
      {
        return asImp().mu(e,x);
      }
 
    private:
      Imp& asImp () {return static_cast<Imp &> (*this);}
      const Imp& asImp () const {return static_cast<const Imp &>(*this);}
    };
 
    template<typename T>
    class LinearElasticityDirichletExtensionAdapter
      : public Dune::PDELab::GridFunctionBase<Dune::PDELab::GridFunctionTraits<typename T::Traits::GridViewType,
                                                                               typename T::Traits::RangeFieldType,
                                                                               T::Traits::dimRange, typename T::Traits::RangeType >
                                              ,LinearElasticityDirichletExtensionAdapter<T> >
    {
    public:
      typedef Dune::PDELab::GridFunctionTraits<typename T::Traits::GridViewType,
                                               typename T::Traits::RangeFieldType,
                                               T::Traits::dimRange, typename T::Traits::RangeType > Traits;
 
      LinearElasticityDirichletExtensionAdapter (const typename Traits::GridViewType& g_, T& t_)
        : g(g_), t(t_)
      {}
 
      inline void evaluate (const typename Traits::ElementType& e,
        const typename Traits::DomainType& x,
        typename Traits::RangeType& y) const
      {
        t.u(e,x,y);
      }
 
      inline const typename Traits::GridViewType& getGridView () const
      {
        return g;
      }
 
    private:
      const typename Traits::GridViewType g;
      T& t;
    };
 
  }
}
 
#endif // DUNE_PDELAB_LOCALOPERATOR_LINEARELASTICITYPARAMETER_HH