geometry.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GENERICGEOMETRY_GEOMETRY_HH
#define DUNE_GENERICGEOMETRY_GEOMETRY_HH
 
#warning This header and the code it contains is deprecated.  If you need functionality \
         similar to BasicGeometry, please use the MultiLinearGeometry class.
 
#include <dune/common/typetraits.hh>
#include <dune/common/nullptr.hh>
 
#include <dune/geometry/genericgeometry/mappingprovider.hh>
#include <dune/geometry/genericgeometry/geometrytraits.hh>
 
namespace Dune
{
 
  namespace GenericGeometry
  {
 
    // BasicGeometry
    // -------------
 
    template< int mydim, class Traits >
    class BasicGeometry
    {
      typedef typename Traits :: CoordTraits CoordTraits;
 
      template< int, class > friend class BasicGeometry;
 
    public:
 
      static const int mydimension = mydim;
 
      static const int coorddimension = Traits :: dimWorld;
 
      typedef typename CoordTraits :: ctype ctype;
 
      typedef FieldVector< ctype, mydimension > LocalCoordinate;
 
      typedef FieldVector< ctype, coorddimension > GlobalCoordinate;
 
    private:
      dune_static_assert( (0 <= mydimension), "Geometry dimension must be nonnegative." );
 
      template< bool >
      struct Hybrid
      {
        typedef VirtualMappingFactory< mydimension, Traits > MappingFactory;
      };
 
      template< bool >
      struct NonHybrid
      {
        static const int topologyId = Traits::template hasSingleGeometryType< mydimension >::topologyId;
        typedef typename GenericGeometry::Topology< topologyId, mydimension >::type Topology;
        typedef GenericGeometry::NonHybridMappingFactory< Topology, Traits > MappingFactory;
      };
 
      static const bool hybrid = !Traits::template hasSingleGeometryType< mydimension >::v;
 
    protected:
      typedef typename conditional< hybrid, Hybrid< true >, NonHybrid< false > >::type::MappingFactory MappingFactory;
      typedef typename MappingFactory::Mapping Mapping;
 
    public:
      typedef typename Mapping::JacobianTransposed JacobianTransposed;
      typedef typename Mapping::JacobianInverseTransposed Jacobian;
      // for cenvencience, Jacobian is the name of the type in the geometry interface
      typedef Jacobian JacobianInverseTransposed;
 
    public:
      BasicGeometry ()
        : mapping_( nullptr )
      {}
 
      template< class CoordVector >
      BasicGeometry ( const GeometryType &type, const CoordVector &coords )
      {
        assert(type.dim() == mydim);
        mapping_ = MappingFactory::construct( type.id(), coords, mappingStorage_ );
      }
 
      template< class CoordVector >
      BasicGeometry ( const CoordVector &coords )
      {
        GeometryType type;
        type.makeFromVertices( mydim, coords.size() );
        mapping_ = MappingFactory::construct( type.id(), coords, mappingStorage_ );
      }
 
      template< int fatherdim >
      BasicGeometry ( const BasicGeometry< fatherdim, Traits > &father, int i )
      {
        const unsigned int codim = fatherdim - mydim;
        mapping_ = father.mapping_->template trace< codim >( i, mappingStorage_ );
      }
 
      BasicGeometry ( const BasicGeometry &other )
        : mapping_( other.mapping_ ? other.mapping_->clone( mappingStorage_ ) : nullptr )
      {}
 
      ~BasicGeometry ()
      {
        if( mapping_ )
          mapping_->~Mapping();
      }
 
      const BasicGeometry &operator= ( const BasicGeometry &other )
      {
        if( mapping_ )
          mapping_->~Mapping();
        mapping_ = (other.mapping_) ? other.mapping_->clone( mappingStorage_ ) : nullptr;
        return *this;
      }
 
      operator bool () const
      {
        return bool( mapping_ );
      }
 
      GeometryType type () const
      {
        return mapping_->type();
      }
 
      int corners () const
      {
        return mapping_->numCorners();
      }
 
      GlobalCoordinate corner ( const int i ) const
      {
        return mapping_->corner( i );
      }
 
      GlobalCoordinate global ( const LocalCoordinate &local ) const
      {
        return mapping_->global( local );
      }
 
      LocalCoordinate local ( const GlobalCoordinate &global ) const
      {
        return mapping_->local( global );
      }
 
      GlobalCoordinate center () const
      {
        return mapping_->center();
      }
 
      bool affine () const
      {
        return mapping_->affine();
      }
 
      ctype integrationElement ( const LocalCoordinate &local ) const
      {
        return mapping_->integrationElement( local );
      }
 
      ctype 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 );
      }
 
    private:
 
      Mapping* mapping_;
 
      char mappingStorage_[ MappingFactory::maxMappingSize ];
    };
 
 
 
    // Geometry
    // --------
 
    template< int mydim, int cdim, class Grid >
    class Geometry
      : public BasicGeometry< mydim, GlobalGeometryTraits< Grid > >
    {
      typedef BasicGeometry< mydim, GlobalGeometryTraits< Grid > > Base;
 
    protected:
      typedef typename Base::Mapping Mapping;
 
    public:
 
      Geometry ()
      {}
 
      template< class Geo >
      explicit Geometry ( const Geo &geo )
        : Base( geo.type(), geo, geo.affine() )
      {}
 
      template< class CoordVector >
      Geometry ( const GeometryType &type, const CoordVector &coords )
        : Base( type, coords )
      {}
 
      template< int fatherdim >
      Geometry ( const Geometry< fatherdim, cdim, Grid > &father, int i )
        : Base( father, i )
      {}
    };
 
 
 
    // LocalGeometry
    // -------------
 
    template< int mydim, int cdim, class Grid >
    class LocalGeometry
      : public BasicGeometry< mydim, LocalGeometryTraits< Grid > >
    {
      typedef BasicGeometry< mydim, LocalGeometryTraits< Grid > > Base;
 
    protected:
      typedef typename Base::Mapping Mapping;
 
    public:
      template< class Geo >
      explicit LocalGeometry ( const Geo &geo )
        : Base( geo.type(), geo, geo.affine() )
      {}
 
      template< class CoordVector >
      LocalGeometry ( const GeometryType &type, const CoordVector &coords )
        : Base( type, coords )
      {}
 
      template< int fatherdim >
      LocalGeometry ( const Geometry< fatherdim, cdim, Grid > &father, int i )
        : Base( father, i )
      {}
    };
 
  }
 
}
 
#endif // #ifndef DUNE_GENERICGEOMETRY_GEOMETRY_HH