hybridmapping.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOMETRY_GENERICGEOMETRY_HYBRIDMAPPING_HH
#define DUNE_GEOMETRY_GENERICGEOMETRY_HYBRIDMAPPING_HH
 
#include <cstddef>
 
#include <dune/common/typetraits.hh>
 
#include <dune/geometry/genericgeometry/cachedmapping.hh>
#include <dune/geometry/genericgeometry/geometrytraits.hh>
#include <dune/geometry/genericgeometry/traceprovider.hh>
 
namespace Dune
{
 
  namespace GenericGeometry
  {
 
    // Internal Forward Declarations
    // -----------------------------
 
    template< unsigned int dim, class GeometryTraits >
    class HybridMapping;
 
    template< class Topology, class GeometryTraits >
    class VirtualMapping;
 
 
 
    // HybridMappingBase
    // -----------------
 
    template< unsigned int dim, class GeometryTraits, unsigned int codim = dim >
    class HybridMappingBase;
 
    template< unsigned int dim, class GeometryTraits, unsigned int codim >
    class HybridMappingBase
      : public virtual HybridMappingBase< dim, GeometryTraits, codim-1 >
    {
      typedef HybridMapping< dim, GeometryTraits > Mapping;
 
    public:
      virtual ~HybridMappingBase() {}
 
    protected:
      using HybridMappingBase< dim, GeometryTraits, codim-1 >::trace;
 
      virtual HybridMapping< dim - codim, GeometryTraits > *
      trace ( integral_constant< int, codim >, unsigned int i, char *mappingStorage ) const = 0;
    };
 
    template< unsigned int dim, class GeometryTraits >
    class HybridMappingBase< dim, GeometryTraits, 0 >
    {
      typedef HybridMapping< dim, GeometryTraits > Mapping;
 
    public:
      virtual ~HybridMappingBase() {}
 
    protected:
      virtual HybridMapping< dim, GeometryTraits > *
      trace ( integral_constant< int, 0 >, unsigned int i, char *mappingStorage ) const = 0;
    };
    // HybridMapping
    // -------------
 
    template< unsigned int dim, class GeometryTraits >
    class HybridMapping
      : public virtual HybridMappingBase< dim, GeometryTraits >
    {
      typedef HybridMapping< dim, GeometryTraits > This;
 
    protected:
      typedef MappingTraits< typename GeometryTraits::CoordTraits, dim, GeometryTraits::dimWorld > Traits;
 
    public:
      static const unsigned int dimension = Traits::dimension;
      static const unsigned int dimWorld = Traits::dimWorld;
 
      typedef typename Traits::FieldType FieldType;
      typedef typename Traits::LocalCoordinate LocalCoordinate;
      typedef typename Traits::GlobalCoordinate GlobalCoordinate;
 
      typedef CachedJacobianTransposed< dimension, GeometryTraits > JacobianTransposed;
      typedef CachedJacobianInverseTransposed< dimension, GeometryTraits > JacobianInverseTransposed;
 
      template< int codim >
      struct Codim
      {
        typedef HybridMapping< dimension - codim, GeometryTraits > Trace;
      };
 
      typedef typename GeometryTraits::Caching Caching;
      typedef typename GeometryTraits::UserData UserData;
 
      virtual ~HybridMapping ()
      {}
 
      virtual bool affine () const = 0;
      virtual Dune::GeometryType type () const = 0;
 
      virtual int numCorners () const = 0;
      virtual GlobalCoordinate corner ( int i ) const = 0;
      virtual GlobalCoordinate center () const = 0;
 
      virtual GlobalCoordinate global ( const LocalCoordinate &x ) const = 0;
      virtual LocalCoordinate local ( const GlobalCoordinate &y ) const = 0;
 
      virtual bool checkInside ( const LocalCoordinate &x ) const = 0;
 
      virtual FieldType integrationElement ( const LocalCoordinate &x ) const = 0;
      virtual FieldType volume () const = 0;
 
      virtual const JacobianTransposed &jacobianTransposed ( const LocalCoordinate &x ) const = 0;
      virtual const JacobianInverseTransposed &jacobianInverseTransposed ( const LocalCoordinate &x ) const = 0;
 
    protected:
      using HybridMappingBase< dim, GeometryTraits >::trace;
 
    public:
      virtual This *clone () const = 0;
      virtual This *clone ( char *mappingStorage ) const = 0;
 
      template< int codim >
      typename Codim< codim >::Trace *trace ( unsigned int i, char *mappingStorage ) const
      {
        integral_constant< int, codim > codimVariable;
        return trace( codimVariable, i, mappingStorage );
      }
 
      const UserData &userData () const { return userData_; }
      UserData &userData () { return userData_; }
 
    private:
      UserData userData_;
    };
 
 
 
    // VirtualMappingBase
    // ------------------
 
    template< class Topology, class GeometryTraits, unsigned int codim = Topology::dimension >
    class VirtualMappingBase;
 
    template< class Topology, class GeometryTraits, unsigned int codim >
    class VirtualMappingBase
      : public VirtualMappingBase< Topology, GeometryTraits, codim-1 >,
        public virtual HybridMappingBase< Topology::dimension, GeometryTraits, codim >
    {
      typedef GenericGeometry::VirtualMapping< Topology, GeometryTraits >
      VirtualMapping;
 
    protected:
      using VirtualMappingBase< Topology, GeometryTraits, codim-1 >::trace;
 
      virtual HybridMapping< Topology::dimension - codim, GeometryTraits > *
      trace ( integral_constant< int, codim >, unsigned int i, char *mappingStorage ) const
      {
        return static_cast< const VirtualMapping & >( *this ).template trace< codim >( i, mappingStorage );
      }
    };
 
    template< class Topology, class GeometryTraits >
    class VirtualMappingBase< Topology, GeometryTraits, 0 >
      : public virtual HybridMappingBase< Topology::dimension, GeometryTraits, 0 >
    {
      typedef GenericGeometry::VirtualMapping< Topology, GeometryTraits >
      VirtualMapping;
 
    protected:
      virtual HybridMapping< Topology::dimension, GeometryTraits > *
      trace ( integral_constant< int, 0 >, unsigned int i, char *mappingStorage ) const
      {
        return static_cast< const VirtualMapping & >( *this ).template trace< 0 >( i, mappingStorage );
      }
    };
    template< class Topology, class GeometryTraits >
    class VirtualMapping
      : public HybridMapping< Topology::dimension, GeometryTraits >,
        public VirtualMappingBase< Topology, GeometryTraits >
    {
      typedef HybridMapping< Topology::dimension, GeometryTraits > Base;
      typedef VirtualMapping< Topology, GeometryTraits > This;
 
      typedef typename Base::Traits Traits;
 
      typedef CachedMapping< Topology, GeometryTraits > Mapping;
 
    public:
      static const unsigned int dimension = Traits::dimension;
      static const unsigned int dimWorld = Traits::dimWorld;
 
      typedef typename Traits::FieldType FieldType;
      typedef typename Traits::LocalCoordinate LocalCoordinate;
      typedef typename Traits::GlobalCoordinate GlobalCoordinate;
 
      typedef typename Base::JacobianTransposed JacobianTransposed;
      typedef typename Base::JacobianInverseTransposed JacobianInverseTransposed;
 
      typedef typename Mapping::ReferenceElement ReferenceElement;
 
      template< unsigned int codim >
      struct Codim
      {
        typedef typename TraceProvider< Topology, GeometryTraits, codim, true >::Trace Trace;
      };
 
      typedef typename GeometryTraits::Caching Caching;
 
      template< class CoordVector >
      explicit VirtualMapping ( const CoordVector &coordVector )
        : mapping_( coordVector )
      {}
 
      virtual bool affine () const { return mapping_.affine(); }
      virtual Dune::GeometryType type () const { return mapping_.type(); }
 
      virtual int numCorners () const { return mapping_.numCorners(); }
      virtual GlobalCoordinate corner ( int i ) const { return mapping_.corner( i ); }
      virtual GlobalCoordinate center () const { return mapping_.center(); }
 
      virtual GlobalCoordinate global ( const LocalCoordinate &local ) const { return mapping_.global( local ); }
      virtual LocalCoordinate local ( const GlobalCoordinate &global ) const { return mapping_.local( global ); }
 
      virtual bool checkInside ( const LocalCoordinate &local ) const { return mapping_.checkInside( local ); }
 
      virtual FieldType integrationElement ( const LocalCoordinate &local ) const { return mapping_.integrationElement( local ); }
      virtual FieldType volume () const { return mapping_.volume(); }
 
      virtual const JacobianTransposed &jacobianTransposed ( const LocalCoordinate &local ) const { return mapping_.jacobianTransposed( local ); }
      virtual const JacobianInverseTransposed &jacobianInverseTransposed ( const LocalCoordinate &local ) const { return mapping_.jacobianInverseTransposed( local ); }
 
      virtual Base *clone () const { return new This( *this ); }
      virtual Base* clone ( char *mappingStorage ) const { return new( mappingStorage ) This( *this ); }
 
      template< int codim >
      typename Codim< codim >::Trace *trace ( unsigned int i, char *mappingStorage ) const
      {
        return TraceProvider< Topology, GeometryTraits, codim, true >::construct( mapping_.mapping(), i, mappingStorage );
      }
 
    protected:
      using VirtualMappingBase< Topology, GeometryTraits >::trace;
 
    private:
      Mapping mapping_;
    };
 
 
 
    // NonHybridMapping
    // ----------------
 
    template< class Topology, class GeometryTraits >
    class NonHybridMapping
    {
      typedef NonHybridMapping< Topology, GeometryTraits > This;
 
    protected:
      typedef MappingTraits< typename GeometryTraits::CoordTraits, Topology::dimension, GeometryTraits::dimWorld > Traits;
 
      typedef CachedMapping< Topology, GeometryTraits > Mapping;
 
    public:
      static const unsigned int dimension = Traits::dimension;
      static const unsigned int dimWorld = Traits::dimWorld;
 
      typedef typename Traits::FieldType FieldType;
      typedef typename Traits::LocalCoordinate LocalCoordinate;
      typedef typename Traits::GlobalCoordinate GlobalCoordinate;
 
      typedef CachedJacobianTransposed< dimension, GeometryTraits > JacobianTransposed;
      typedef CachedJacobianInverseTransposed< dimension, GeometryTraits > JacobianInverseTransposed;
 
      typedef typename Mapping::ReferenceElement ReferenceElement;
 
      template< unsigned int codim >
      struct Codim
      {
        typedef typename TraceProvider< Topology, GeometryTraits, codim, false >::Trace Trace;
      };
 
      typedef typename GeometryTraits::Caching Caching;
      typedef typename GeometryTraits::UserData UserData;
 
      template< class CoordVector >
      explicit NonHybridMapping ( const CoordVector &coordVector )
        : mapping_( coordVector )
      {}
 
      bool affine () const { return mapping_.affine(); }
      Dune::GeometryType type () const { return mapping_.type(); }
 
      int numCorners () const { return mapping_.numCorners(); }
      GlobalCoordinate corner ( int i ) const { return mapping_.corner( i ); }
      GlobalCoordinate center () const { return mapping_.center(); }
 
      GlobalCoordinate global ( const LocalCoordinate &local ) const { return mapping_.global( local ); }
      LocalCoordinate local ( const GlobalCoordinate &global ) const { return mapping_.local( global ); }
 
      bool checkInside ( const LocalCoordinate &local ) const { return mapping_.checkInside( local ); }
 
      FieldType integrationElement ( const LocalCoordinate &local ) const { return mapping_.integrationElement( local ); }
      FieldType volume () const { return mapping_.volume(); }
 
      const JacobianTransposed &jacobianTransposed ( const LocalCoordinate &local ) const { return mapping_.jacobianTransposed( local ); }
      const JacobianInverseTransposed &jacobianInverseTransposed ( const LocalCoordinate &local ) const { return mapping_.jacobianInverseTransposed( local ); }
 
      This *clone () const { return new This( *this ); }
      This *clone ( char *mappingStorage ) const { return new( mappingStorage ) This( *this ); }
 
      template< int codim >
      typename Codim< codim >::Trace *trace ( unsigned int i, char *mappingStorage ) const
      {
        return TraceProvider< Topology, GeometryTraits, codim, false >::construct( mapping_.mapping(), i, mappingStorage );
      }
 
      const UserData &userData () const { return userData_; }
      UserData &userData () { return userData_; }
 
    private:
      UserData userData_;
      Mapping mapping_;
    };
 
  } // namespace GenericGeometry
 
} // namespace Dune
 
#endif // #ifndef DUNE_GEOMETRY_GENERICGEOMETRY_HYBRIDMAPPING_HH