identitygridgeometry.hh

Go to the documentation of this file.

#ifndef DUNE_IDENTITYGRIDGEOMETRY_HH
#define DUNE_IDENTITYGRIDGEOMETRY_HH

#include <dune/common/fmatrix.hh>
#include <dune/common/typetraits.hh>
#include <dune/grid/common/geometry.hh>

namespace Dune {

template<int mydim, int coorddim, class GridImp>
class IdentityGridGeometry :
    public GeometryDefaultImplementation <mydim, coorddim, GridImp, IdentityGridGeometry>
{
    private:
    
        typedef typename GridImp::ctype ctype;
    
    
    public:
    
        // The codimension of this entitypointer wrt the host grid
        enum {CodimInHostGrid = GridImp::HostGridType::dimension - mydim};
        enum {DimensionWorld = GridImp::HostGridType::dimensionworld};
    
        typedef FieldMatrix< ctype, mydim, coorddim > JacobianTransposed;

        // select appropiate hostgrid geometry via typeswitch
        typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Geometry HostGridGeometryType;
        typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Geometry HostGridLocalGeometryType;
        
        typedef typename SelectType<coorddim==DimensionWorld, HostGridGeometryType, HostGridLocalGeometryType>::Type HostGridGeometry;
        
        
        IdentityGridGeometry(const HostGridGeometry& hostGeometry)
            : hostGeometry_(hostGeometry)
        {
        }
    
        
        GeometryType type () const {
            return hostGeometry_.type();
        }

        // return wether we have an affine mapping
        bool affine() const {
            return hostGeometry_.affine();
        }

        int corners () const {
            return hostGeometry_.corners();
        }
    
        
        const FieldVector<ctype, coorddim> corner (int i) const {
            return hostGeometry_.corner(i);
        }
    
        
        FieldVector<ctype, coorddim> global (const FieldVector<ctype, mydim>& local) const{
            return hostGeometry_.global(local);
        }
    
        const JacobianTransposed &
        jacobianTransposed ( const FieldVector<ctype, mydim>& local ) const {
            return hostGeometry_.jacobianTransposed(local);
        }

        FieldVector<ctype, mydim> local (const FieldVector<ctype, coorddim>& global) const {
            return hostGeometry_.local(global);
        }
    
        
        bool checkInside(const FieldVector<ctype, mydim> &local) const {
            return hostGeometry_.checkInside(local);
        }
    
        
        ctype integrationElement (const FieldVector<ctype, mydim>& local) const {
            return hostGeometry_.integrationElement(local);
        }
    
        
        const FieldMatrix<ctype, coorddim,mydim>& jacobianInverseTransposed (const FieldVector<ctype, mydim>& local) const {
            return hostGeometry_.jacobianInverseTransposed(local);
        }
    
        
        HostGridGeometry hostGeometry_;
        
};


namespace FacadeOptions
{

template< int mydim, int coorddim, class GridImp >
struct StoreGeometryReference< mydim, coorddim, GridImp, IdentityGridGeometry >
{
        static const bool v = false;
};

}  // namespace FacadeOptions


}  // namespace Dune

#endif