referenceelement.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_GEOMETRY_REFERENCEELEMENT_HH
#define DUNE_GEOMETRY_REFERENCEELEMENT_HH

#include <dune/geometry/type.hh>

namespace Dune {
  namespace Geo {

    namespace Impl {

      // forward declaration for friend declaration
      template<typename ctype, int dim>
      class ReferenceElementContainer;

    }

    // forward declaration for constructing default reference element type
    template<typename ctype, int dim>
    class ReferenceElementImplementation;

    // forward declaration for backwards compatibility conversion
    template<typename ctype, int dim>
    struct ReferenceElements;

    // ReferenceElement
    // ----------------

    template<typename Implementation>
    class ReferenceElement
    {

    public:

#ifndef DOXYGEN

      template<int codim>
      using Codim = typename Implementation::template Codim<codim>;

#else

      template< int codim >
      struct Codim
      {
        using Geometry = implementation-defined;
      };

#endif // DOXYGEN

      using ctype = typename Implementation::ctype;

      using CoordinateField = ctype;

      using Coordinate = typename Implementation::Coordinate;

      typedef ctype Volume;

      static constexpr int dimension = Implementation::dimension;


      int size(int c) const
      {
        return _impl->size(c);
      }


      int size(int i, int c, int cc) const
      {
        return _impl->size(i,c,cc);
      }


      int subEntity(int i, int c, int ii, int cc) const
      {
        return _impl->subEntity(i,c,ii,cc);
      }

      auto subEntities ( int i, int c, int cc ) const
      {
        return _impl->subEntities(i,c,cc);
      }


      GeometryType type(int i, int c) const
      {
        return _impl->type(i,c);
      }


      GeometryType type() const
      {
        return _impl->type();
      }


      Coordinate position(int i, int c) const
      {
        return _impl->position(i,c);
      }


      bool checkInside(const Coordinate& local) const
      {
        return _impl->checkInside(local);
      }


      template<int codim>
      typename Codim<codim>::Geometry geometry(int i) const
      {
        return _impl->template geometry<codim>(i);
      }


      CoordinateField volume() const
      {
        return _impl->volume();
      }


      Coordinate integrationOuterNormal(int face) const
      {
        return _impl->integrationOuterNormal(face);
      }


      ReferenceElement()
        : _impl(nullptr)
      {}

      const Implementation& impl() const
      {
        return *_impl;
      }

      bool operator==(const ReferenceElement& r) const
      {
        return _impl == r._impl;
      }

      bool operator!=(const ReferenceElement& r) const
      {
        return not (*this == r);
      }

      friend std::size_t hash_value(const ReferenceElement& r)
      {
        return reinterpret_cast<std::size_t>(r._impl);
      }

    private:

      // The implementation must be a friend to construct a wrapper around itself.
      friend Implementation;

      // The reference container is a friend to be able to call setImplementation.
      friend class Impl::ReferenceElementContainer<ctype,dimension>;

      // Constructor for wrapping an implementation reference (required internally by the default implementation)
      ReferenceElement(const Implementation& impl)
        : _impl(&impl)
      {}

      void setImplementation(const Implementation& impl)
      {
        _impl = &impl;
      }

      const Implementation* _impl;

    };

  }

}


#endif // DUNE_GEOMETRY_REFERENCEELEMENT_HH