traversal.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
#include <ikarus/utils/concepts.hh>
 
namespace Ikarus::utils {
 
template <class T, class TreePath, class PowerFunc, class LeafFunc>
void forEachLeafOrPowerLeafNode(T&& tree, TreePath&& treePath, PowerFunc&& powerFunc, LeafFunc&& leafFunc) {
  using Tree = std::decay_t<T>;
  if constexpr (Tree::isLeaf) {
    leafFunc(tree, treePath);
  } else if constexpr (Tree::isPower) {
    if constexpr (Tree::template Child<Dune::Indices::_0>::Type::isLeaf) {
      powerFunc(tree, treePath);
    } else {
      for (std::size_t i = 0; i < tree.degree(); ++i) {
        auto childTreePath = Dune::TypeTree::push_back(treePath, i);
        forEachLeafOrPowerLeafNode(tree.child(i), childTreePath, powerFunc, leafFunc);
      }
    }
  } else {
    auto indices = std::make_index_sequence<Tree::degree()>{};
    Dune::Hybrid::forEach(indices, [&](auto i) {
      auto childTreePath = Dune::TypeTree::push_back(treePath, i);
      forEachLeafOrPowerLeafNode(tree.child(i), childTreePath, powerFunc, leafFunc);
    });
  }
}
 
template <typename LV, typename F, int size = LV::Element::Geometry::coorddimension>
requires(std::convertible_to<F, std::function<bool(int, Dune::FieldVector<double, size> &&)>>)
void forEachLagrangeNodePosition(const LV& localView, F&& f) {
  static_assert(Concepts::LagrangeNode<std::remove_cvref_t<decltype(localView.tree().child(0))>>,
                "forEachLagrangeNodePosition is only supported for Lagrange power basis");
  assert(localView.bound() && "The local view must be bound to an element");
  const auto& localFE = localView.tree().child(0).finiteElement();
  std::vector<Dune::FieldVector<double, size>> lagrangeNodeCoords;
  lagrangeNodeCoords.resize(localFE.size());
  std::vector<double> out;
  for (int i = 0; i < size; i++) {
    auto ithCoord = [&i](const Dune::FieldVector<double, size>& x) { return x[i]; };
    localFE.localInterpolation().interpolate(ithCoord, out);
    for (std::size_t j = 0; j < out.size(); j++)
      lagrangeNodeCoords[j][i] = out[j];
  }
  for (int nodeNumber = 0; auto& nCoord : lagrangeNodeCoords)
    if (f(nodeNumber++, std::move(nCoord)))
      break;
}
} // namespace Ikarus::utils