interfaceswitch.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
 
#ifndef DUNE_LOCALFUNCTIONS_COMMON_INTERFACESWITCH_HH
#define DUNE_LOCALFUNCTIONS_COMMON_INTERFACESWITCH_HH
 
#include <cstddef>
#include <memory>
#include <vector>
 
#include <dune/common/fmatrix.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/shared_ptr.hh>
 
namespace Dune {
 
 
  template<class FiniteElement, class Dummy = void>
  struct FiniteElementInterfaceSwitch {
    typedef typename FiniteElement::Traits::Basis Basis;
    typedef typename FiniteElement::Traits::Interpolation Interpolation;
    typedef typename FiniteElement::Traits::Coefficients Coefficients;
 
    static const Basis &basis(const FiniteElement& fe)
    { return fe.basis(); }
    static const Interpolation &interpolation(const FiniteElement& fe)
    { return fe.interpolation(); }
    static const Coefficients &coefficients(const FiniteElement& fe)
    { return fe.coefficients(); }
 
 
    typedef std::shared_ptr<const FiniteElement> Store;
 
    static void setStore(Store& store, const FiniteElement& fe)
    { store = std::make_shared<const FiniteElement>(fe); }
    static void setStore(Store& store, FiniteElement&& fe)
    { store = std::make_shared<const FiniteElement>(std::move(fe)); }
    static void setStore(Store& store, const Store& fe)
    { store = fe; }
  };
 
#ifndef DOXYGEN
  template<class FiniteElement>
  struct FiniteElementInterfaceSwitch<
      FiniteElement,
      typename std::enable_if<AlwaysTrue<typename FiniteElement::Traits::
              LocalBasisType>::value>::type
      >
  {
    typedef typename FiniteElement::Traits::LocalBasisType Basis;
    typedef typename FiniteElement::Traits::LocalInterpolationType
    Interpolation;
    typedef typename FiniteElement::Traits::LocalCoefficientsType Coefficients;
 
    static const Basis &basis(const FiniteElement& fe)
    { return fe.localBasis(); }
    static const Interpolation &interpolation(const FiniteElement& fe)
    { return fe.localInterpolation(); }
    static const Coefficients &coefficients(const FiniteElement& fe)
    { return fe.localCoefficients(); }
 
    typedef std::shared_ptr<const FiniteElement> Store;
    static void setStore(Store& store, const FiniteElement& fe)
    { store = stackobject_to_shared_ptr<const FiniteElement>(fe); }
    static void setStore(Store& store, FiniteElement&& fe)
    { store = std::make_shared<const FiniteElement>(std::move(fe)); }
    static void setStore(Store& store, const Store& fe)
    { store = fe; }
  };
#endif // !DOXYGEN
 
 
  template<class Basis, class Dummy = void>
  struct BasisInterfaceSwitch {
    typedef typename Basis::Traits::DomainField DomainField;
    static const std::size_t dimDomainLocal = Basis::Traits::dimDomainLocal;
    typedef typename Basis::Traits::DomainLocal DomainLocal;
 
    typedef typename Basis::Traits::RangeField RangeField;
    static const std::size_t dimRange = Basis::Traits::dimRange;
    typedef typename Basis::Traits::Range Range;
 
 
    template<typename Geometry>
    static void gradient(const Basis& basis, const Geometry& geometry,
                         const DomainLocal& xl,
                         std::vector<FieldMatrix<RangeField, 1,
                                 Geometry::coorddimension> >& grad)
    {
      grad.resize(basis.size());
      basis.evaluateJacobian(xl, grad);
    }
  };
 
#ifndef DOXYGEN
  template<class Basis>
  struct BasisInterfaceSwitch<Basis,
                              typename std::enable_if<
                                AlwaysTrue<
                                  std::integral_constant<
                                    std::size_t,
                                    Basis::Traits::dimDomain
                                    >
                                  >::value
                                >::type
                              >
  {
    typedef typename Basis::Traits::DomainFieldType DomainField;
    static const std::size_t dimDomainLocal = Basis::Traits::dimDomain;
    typedef typename Basis::Traits::DomainType DomainLocal;
 
    typedef typename Basis::Traits::RangeFieldType RangeField;
    static const std::size_t dimRange = Basis::Traits::dimRange;
    typedef typename Basis::Traits::RangeType Range;
 
    template<typename Geometry>
    static void gradient(const Basis& basis, const Geometry& geometry,
                         const DomainLocal& xl,
                         std::vector<FieldMatrix<RangeField, 1,
                                 Geometry::coorddimension> >& grad)
    {
      std::vector<typename Basis::Traits::JacobianType> lgrad(basis.size());
      basis.evaluateJacobian(xl, lgrad);
 
      const typename Geometry::JacobianInverseTransposed& jac =
        geometry.jacobianInverseTransposed(xl);
 
      grad.resize(basis.size());
      for(std::size_t i = 0; i < basis.size(); ++i)
        jac.mv(lgrad[i][0], grad[i][0]);
    }
  };
#endif // !DOXYGEN
 
} // namespace Dune
 
#endif // DUNE_LOCALFUNCTIONS_COMMON_INTERFACESWITCH_HH