pullbackfunction.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-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUFEM_FUNCTIONS_PULLBACKFUNCTION_HH
#define DUNE_FUFEM_FUNCTIONS_PULLBACKFUNCTION_HH
 
#include <optional>
#include <type_traits>
#include <utility>
 
#include <dune/common/exceptions.hh>
#include <dune/common/referencehelper.hh>
 
#include <dune/functions/common/defaultderivativetraits.hh>
#include <dune/functions/gridfunctions/gridfunction.hh>
#include <dune/functions/gridfunctions/gridviewentityset.hh>
 
namespace Dune::Fufem::Experimental {
 
 
 
// Forward definition
template<class GeometryGrid>
class GeometryGridForwardMorphism;
 
 
 
// Forward definition
template<class GeometryGrid>
class GeometryGridReverseMorphism;
 
 
 
template<class GeometryGrid>
class GeometryGridForwardMorphism
{
  using HostGrid = typename GeometryGrid::HostGrid;
 
  template<class HostGridView>
  static auto gridViewImpl(const GeometryGrid& geoGrid, const HostGridView& hostGridView)
  {
    if constexpr (std::is_same_v<HostGridView, typename HostGrid::LeafGridView>)
      return geoGrid.leafGridView();
    if constexpr (std::is_same_v<HostGridView, typename HostGrid::LevelGridView>)
      return geoGrid.levelGridView(hostGridView.template begin<0>().level());
  }
 
  template<int codim>
  using Entity = typename GeometryGrid::template Codim<codim>::Entity;
 
public:
 
  using Inverse = GeometryGridReverseMorphism<GeometryGrid>;
 
  using Grid = GeometryGrid;
 
  template<class HostGridView>
  using GridView = decltype(gridViewImpl(std::declval<GeometryGrid>(), std::declval<HostGridView>()));
 
  GeometryGridForwardMorphism(const GeometryGrid& grid)
    : geoGridPtr_(&grid)
  {}
 
  template<class HostEntity>
  Entity<HostEntity::codimension> entity(const HostEntity& hostEntity) const
  {
    using EntityImplementation = typename Entity<HostEntity::codimension>::Implementation;
    return Entity<HostEntity::codimension>(EntityImplementation(*geoGridPtr_, hostEntity));
  }
 
  template<class HostGridView>
  auto gridView(const HostGridView& hostGridView) const
  {
    return gridViewImpl(*geoGridPtr_, hostGridView);
  }
 
  auto inverse() const
  {
    return GeometryGridReverseMorphism(*geoGridPtr_);
  }
 
private:
  const GeometryGrid* geoGridPtr_;
};
 
 
 
template<class GeometryGrid>
class GeometryGridReverseMorphism
{
  using HostGrid = typename GeometryGrid::HostGrid;
 
  template<int codim>
  using Entity = typename HostGrid::template Codim<codim>::Entity;
 
public:
 
  using Inverse = GeometryGridForwardMorphism<GeometryGrid>;
 
  using Grid = HostGrid;
 
  template<class GeometryGridView>
  using GridView = typename GeometryGridView::Implementation::HostGridView;
 
  GeometryGridReverseMorphism(const GeometryGrid& grid)
    : geoGridPtr_(&grid)
  {}
 
  template<class GeoEntity>
  const Entity<GeoEntity::codimension>& entity(const GeoEntity& geoEntity) const
  {
    return geoEntity.impl().hostEntity();
  }
 
  template<class GeoGridView>
  auto gridView(const GeoGridView& geoGridView) const
  {
    return geoGridView.impl().hostGridView();
  }
 
  auto inverse() const
  {
    return GeometryGridForwardMorphism(*geoGridPtr_);
  }
 
private:
  const GeometryGrid* geoGridPtr_;
};
 
 
 
template<class GridFunction, class GridMorphism, template<class> class DerivativeTraits=Dune::Functions::DefaultDerivativeTraits>
class PullBackFunction
{
  using RawGridFunction = Dune::ResolveRef_t<GridFunction>;
 
  auto&& rawFunction() const
  {
    return Dune::resolveRef(function_);
  }
 
  using RawEntitySet = std::decay_t<decltype(std::declval<RawGridFunction>().entitySet())>;
  using RawDomain = typename RawEntitySet::GlobalCoordinate;
  using RawGridView = typename RawEntitySet::GridView;
  using RawElement = typename RawEntitySet::Element;
 
public:
 
  using GridView = typename GridMorphism::Inverse::GridView<RawGridView>;
  using EntitySet = Dune::Functions::GridViewEntitySet<GridView, 0>;
  using Element = typename EntitySet::Element;
  using Domain = typename EntitySet::GlobalCoordinate;
  using LocalDomain = typename EntitySet::LocalCoordinate;
  using Range = std::decay_t<decltype(std::declval<RawGridFunction>()(std::declval<RawDomain>()))>;
 
private:
 
  using Traits = Dune::Functions::Imp::GridFunctionTraits<Range(Domain), EntitySet, DerivativeTraits, 56>;
 
  class PullBackLocalFunction
  {
    using Traits = typename PullBackFunction::Traits::LocalFunctionTraits;
 
  public:
 
    using Derivative = decltype(localFunction(derivative(std::declval<PullBackFunction>())));
    using RawLocalFunction = std::decay_t<decltype(localFunction(std::declval<const RawGridFunction&>()))>;
 
    PullBackLocalFunction(RawLocalFunction&& localFunction, const GridMorphism& morphism)
      : localFunction_(localFunction)
      , morphismPtr_(&morphism)
      , element_()
    {}
 
    PullBackLocalFunction(RawLocalFunction&& localFunction, const GridMorphism& morphism, const std::optional<Element>& element)
      : localFunction_(localFunction)
      , morphismPtr_(&morphism)
      , element_(element)
    {}
 
    void bind(const Element& element)
    {
      element_ = element;
      localFunction_.bind(morphismPtr_->entity(element));
    }
 
    void unbind()
    {
      localFunction_.unbind();
      element_.reset();
    }
 
    bool bound() const
    {
      return static_cast<bool>(element_);
    }
 
    const Element& localContext() const
    {
      return *element_;
    }
 
    friend auto derivative(const PullBackLocalFunction& f)
    {
      if constexpr(requires{ derivative(f.localFunction_); })
        return Derivative(derivative(f.localFunction_), *f.morphismPtr_, f.element_);
      else
        return typename Traits::DerivativeInterface{};
    }
 
    Range operator()(LocalDomain x) const
    {
      return localFunction_(x);
    }
 
  private:
    RawLocalFunction localFunction_;
    const GridMorphism* morphismPtr_;
    std::optional<Element> element_;
  };
 
public:
 
  using LocalFunction = PullBackLocalFunction;
 
  PullBackFunction(GridFunction function, GridMorphism morphism)
    : function_(std::move(function))
    , morphism_(std::move(morphism))
    , entitySet_(morphism_.inverse().gridView(rawFunction().entitySet().gridView()))
  {}
 
  Range operator()(const Domain& x) const
  {
    DUNE_THROW(Dune::NotImplemented, "Evaluation of PullBackFunction in global coordinates is not implemented");
  }
 
  friend auto derivative(const PullBackFunction& f)
  {
    if constexpr(requires{ derivative(f.rawFunction()); })
    {
      using RawDerivative = std::decay_t<decltype(derivative(f.rawFunction()))>;
      return PullBackFunction<RawDerivative, GridMorphism, DerivativeTraits>(derivative(f.rawFunction()), f.morphism_);
    }
    else
      return typename Traits::DerivativeInterface{};
  }
 
  friend LocalFunction localFunction(const PullBackFunction& f)
  {
    return LocalFunction(localFunction(f.rawFunction()), f.morphism_);
  }
 
  const EntitySet& entitySet() const
  {
    return entitySet_;
  }
 
private:
 
  GridFunction function_;
  GridMorphism morphism_;
  EntitySet entitySet_;
};
 
 
 
template<class GeometryGridFunction>
auto pullBackToHostGrid(GeometryGridFunction gridFunction)
{
  const auto& grid = gridFunction.entitySet().gridView().grid();
  return Dune::Fufem::Experimental::PullBackFunction(std::move(gridFunction), Dune::Fufem::Experimental::GeometryGridForwardMorphism(grid));
}
 
 
 
template<class HostGridFunction, class GeometryGrid>
auto pullBackToGeometryGrid(HostGridFunction gridFunction, const GeometryGrid& geometryGrid)
{
  return Dune::Fufem::Experimental::PullBackFunction(std::move(gridFunction), Dune::Fufem::Experimental::GeometryGridReverseMorphism(geometryGrid));
}
 
 
 
} // namespace Dune::Fufem::Experimental
 
#endif // DUNE_FUFEM_FUNCTIONS_PULLBACKFUNCTION_HH