referenceelementgeometry.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_TEST_REFERENCEELEMENTGEOMETRY_HH
#define DUNE_GEOMETRY_TEST_REFERENCEELEMENTGEOMETRY_HH
 
#include <type_traits>
 
#include <dune/geometry/referenceelements.hh>
 
namespace Dune {
namespace Impl {
 
// Placeholder type for a trivial identity matrix without any functionality
struct IdentityMatrix
{
  // multiply Id * A
  template <class A>
  friend const A& operator* (IdentityMatrix, const A& a) { return a; }
 
  // multiply A * Id
  template <class A>
  friend const A& operator* (const A& a, IdentityMatrix) { return a; }
 
  // multiply Id * Id
  friend IdentityMatrix operator* (IdentityMatrix, IdentityMatrix) { return {}; }
 
  friend std::ostream& operator<< (std::ostream& out, IdentityMatrix)
  {
    return out << "I";
  }
 
  // cast into FieldMatrix
  template <class K, int n>
  operator FieldMatrix<K,n,n> () const
  {
    FieldMatrix<K,n,n> I;
    for (int i = 0; i < n; ++i)
      I[i][i] = K(1);
    return I;
  }
};
 
 
template <class RefElem>
class ReferenceElementGeometry
    : public RefElem::template Codim<0>::Geometry
{
  using Base = typename RefElem::template Codim<0>::Geometry;
 
public:
  using LocalCoordinate = typename RefElem::Coordinate;
  using GlobalCoordinate = typename RefElem::Coordinate;
  using Jacobian = Impl::IdentityMatrix;
  using JacobianTransposed = Impl::IdentityMatrix;
  using JacobianInverse = Impl::IdentityMatrix;
  using JacobianInverseTransposed = Impl::IdentityMatrix;
 
public:
  constexpr explicit ReferenceElementGeometry (const RefElem& refElem)
    : Base{refElem.template geometry<0>(0)}
  {}
 
  constexpr const LocalCoordinate& local (const GlobalCoordinate& global) const noexcept
  {
    return global;
  }
 
  constexpr const GlobalCoordinate& global (const LocalCoordinate& local) const noexcept
  {
    return local;
  }
 
  constexpr Jacobian jacobian (const LocalCoordinate& local) const noexcept
  {
    return Jacobian{};
  }
 
  constexpr JacobianTransposed jacobianTransposed (const LocalCoordinate& local) const noexcept
  {
    return JacobianTransposed{};
  }
 
  constexpr JacobianInverse jacobianInverse (const LocalCoordinate& local) const noexcept
  {
    return JacobianInverse{};
  }
 
  constexpr JacobianInverseTransposed jacobianInverseTransposed (const LocalCoordinate& local) const noexcept
  {
    return JacobianInverseTransposed{};
  }
};
 
 
template <class Geometry>
class LocalDerivativeGeometry
    : public ReferenceElementGeometry<
        typename Dune::ReferenceElements<typename Geometry::ctype, Geometry::mydimension>::ReferenceElement >
{
  using ReferenceElements = Dune::ReferenceElements<typename Geometry::ctype, Geometry::mydimension>;
  using ReferenceElement = typename ReferenceElements::ReferenceElement;
  using Base = ReferenceElementGeometry<ReferenceElement>;
 
public:
  using LocalCoordinate = typename Geometry::LocalCoordinate;
  using Jacobian = typename Geometry::Jacobian;
  using JacobianTransposed = typename Geometry::JacobianTransposed;
  using JacobianInverse = typename Geometry::JacobianInverse;
  using JacobianInverseTransposed = typename Geometry::JacobianInverseTransposed;
 
public:
  explicit LocalDerivativeGeometry (const Geometry& geometry) noexcept
    : Base(referenceElement(geometry))
    , geometry_(geometry)
  {}
 
  Jacobian jacobian (const LocalCoordinate& local) const
  {
    return geometry_.jacobian(local);
  }
 
  JacobianTransposed jacobianTransposed (const LocalCoordinate& local) const
  {
    return geometry_.jacobianTransposed(local);
  }
 
  JacobianInverse jacobianInverse (const LocalCoordinate& local) const
  {
    return geometry_.jacobianInverse(local);
  }
 
  JacobianInverseTransposed jacobianInverseTransposed (const LocalCoordinate& local) const
  {
    return geometry_.jacobianInverseTransposed(local);
  }
 
private:
  Geometry geometry_;
};
 
} // end namespace Impl
} // end namespace Dune
 
#endif // DUNE_GEOMETRY_TEST_REFERENCEELEMENTGEOMETRY_HH