referenceelements.hh

// -*- 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_REFERENCEELEMENTS_HH
#define DUNE_GEOMETRY_REFERENCEELEMENTS_HH
 
#include <cassert>
 
#include <algorithm>
#include <limits>
#include <tuple>
#include <utility>
#include <vector>
#include <array>
 
#include <dune/common/typetraits.hh>
#include <dune/common/std/type_traits.hh>
#include <dune/common/visibility.hh>
 
#include <dune/geometry/dimension.hh>
#include <dune/geometry/type.hh>
#include <dune/geometry/referenceelement.hh>
#include <dune/geometry/referenceelementimplementation.hh>
 
namespace Dune
{
 
  namespace Geo
  {
 
#ifndef DOXYGEN
 
 
    namespace Impl
    {
 
      // ReferenceElementContainer
      // -------------------------
 
      template< class ctype, int dim >
      class ReferenceElementContainer
      {
        static const unsigned int numTopologies = dim >= 0 ? (1u << dim) : 0;
 
        using Implementation   = ReferenceElementImplementation< ctype, dim >;
 
      public:
 
        using ReferenceElement = Dune::Geo::ReferenceElement< Implementation >;
        using value_type       = ReferenceElement;
        using const_iterator   = const value_type*;
 
        ReferenceElementContainer ()
        {
          for( unsigned int topologyId = 0; topologyId < numTopologies; ++topologyId )
            {
              implementations_[ topologyId ].initialize( topologyId );
              reference_elements_[ topologyId ].setImplementation( implementations_[ topologyId ] );
            }
        }
 
        const ReferenceElement& operator() ( const GeometryType &type ) const
        {
          assert( type.dim() == dim );
          return reference_elements_[ type.id() ];
        }
 
        const ReferenceElement& simplex () const
        {
          return reference_elements_[ Dune::GeometryTypes::simplex(dim).id() ];
        }
 
        const ReferenceElement& cube () const
        {
          return reference_elements_[ Dune::GeometryTypes::cube(dim).id() ];
        }
 
        const ReferenceElement& pyramid () const
        {
          return reference_elements_[ Dune::GeometryTypes::pyramid.id() ];
        }
 
        const ReferenceElement& prism () const
        {
          return reference_elements_[ Dune::GeometryTypes::prism.id() ];
        }
 
        const_iterator begin () const
        {
          return reference_elements_.data();
        }
 
        const_iterator end () const
        {
          return reference_elements_.data() + numTopologies;
        }
 
      private:
 
        std::array<Implementation,numTopologies> implementations_;
        std::array<ReferenceElement,numTopologies> reference_elements_;
 
      };
 
 
    } // namespace Impl
 
 
#endif // DOXYGEN
 
 
    // ReferenceElements
    // ------------------------
 
    template< class ctype_, int dim >
    struct ReferenceElements
    {
 
      using ctype = ctype_;
 
      using CoordinateField = ctype;
 
      static constexpr int dimension = dim;
 
    private:
 
      using Container = Impl::ReferenceElementContainer< ctype, dim >;
 
    public:
 
      using ReferenceElement = typename Container::ReferenceElement;
 
      using Iterator         = typename Container::const_iterator;
 
      using iterator         = Iterator;
 
      static const ReferenceElement&
      general ( const GeometryType& type )
      {
        return container() ( type );
      }
 
      static const ReferenceElement& simplex ()
      {
        return container().simplex();
      }
 
      static const ReferenceElement& cube ()
      {
        return container().cube();
      }
 
      static Iterator begin ()
      {
        return container().begin();
      }
 
      static Iterator end ()
      {
        return container().end();
      }
 
    private:
 
      DUNE_EXPORT static const Container& container ()
      {
        static Container container;
        return container;
      }
    };
 
  } // namespace Geo
 
  using Geo::ReferenceElements;
 
 
#ifdef DOXYGEN
 
 
  template<typename... T>
  unspecified-value-type referenceElement(T&&... t);
 
#endif
 
 
 
  template<typename T, int dim>
  auto referenceElement(const Dune::GeometryType& gt, Dune::Dim<dim> = {})
  {
    return ReferenceElements<T,dim>::general(gt);
  }
 
 
 
  template<typename T, int dim, std::enable_if_t<IsNumber<std::decay_t<T>>::value, int> = 0>
  auto referenceElement(const T&, const Dune::GeometryType& gt, Dune::Dim<dim>)
  {
    return ReferenceElements<T,dim>::general(gt);
  }
 
  template<typename... T>
  using ReferenceElement = decltype(referenceElement(std::declval<T>()...));
 
} // namespace Dune
 
#endif // #ifndef DUNE_GEOMETRY_REFERENCEELEMENTS_HH