febase.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/finiteelements/ferequirements.hh>
#include <ikarus/finiteelements/fetraits.hh>
#include <ikarus/finiteelements/mixin.hh>
 
namespace Ikarus {
 
template <typename PreFE, template <typename, typename> class... Skills>
class FE;
 
template <typename BH, typename FER = FERequirements<>, bool useFlat = true, bool useEigenRef = false>
struct PreFE
{
  using BasisHandler                      = BH;
  using FERequirements                    = FER;
  static constexpr int worldDim           = BasisHandler::Basis::worlddim;
  static constexpr bool useEigenReference = useEigenRef;
  static constexpr bool useFlatBasis      = useFlat;
  using Traits                            = FETraits<BH, FER, useEigenRef, useFlat>;
 
  template <template <typename, typename> class... Skills>
  using FE = FE<PreFE, Skills...>;
};
 
namespace Impl {
  // Since base classes are initialized, in declaration order before member variables, we have to make sure the
  // localview_ object of FE is defined. To do this we add this artificial inheritance by inheriting below first from
  // FEInit, which initializes the localview object first, siche we the other FEMixin base class constructors are called
  template <typename PreFE, typename FE>
  struct FEInit
  {
    using Traits       = PreFE::Traits;              
    using BasisHandler = Traits::BasisHandler;       
    using LocalView    = typename Traits::LocalView; 
    friend FE;
    FEInit(const BasisHandler& basisHandler)
        : localView_{[&]() -> LocalView {
            if constexpr (Traits::useFlatBasis)
              return basisHandler.flat().localView();
            else
              return basisHandler.untouched().localView();
          }()} {}
 
  private:
    LocalView localView_;
  };
} // namespace Impl
 
template <typename PreFE, template <typename, typename> class... Skills>
class FE : private Impl::FEInit<PreFE, FE<PreFE, Skills...>>, public FEMixin<PreFE, Skills...>
{
  friend Impl::FEInit<PreFE, FE>;
 
protected:
  using Mixin = FEMixin<PreFE, Skills...>; 
  friend Mixin;
 
public:
  using Traits            = PreFE::Traits;                
  using BasisHandler      = Traits::BasisHandler;         
  using LocalView         = typename Traits::LocalView;   
  using GridView          = typename Traits::GridView;    
  using GlobalIndex       = typename Traits::GlobalIndex; 
  using GridElement       = typename Traits::Element;     
  using FERequirementType = typename Traits::FERequirementType;
 
  static constexpr int myDim    = Traits::mydim;
  static constexpr int worldDim = Traits::worlddim;
  using PreTuple                = std::tuple<typename Skills<PreFE, FE>::Pre...>;
 
  explicit FE(const BasisHandler& basisHandler, typename Skills<PreFE, FE>::Pre... skillsArgs)
      : Impl::FEInit<PreFE, FE>(basisHandler),
        FEMixin<PreFE, Skills...>(std::forward<typename Skills<PreFE, FE>::Pre>(skillsArgs)...) {}
 
  void bind(const GridElement& element) {
    this->localView_.bind(element);
    Mixin::bind();
  }
 
  [[nodiscard]] constexpr size_t size() const { return this->localView_.size(); }
 
  const GridElement& gridElement() const { return this->localView_.element(); }
 
  const LocalView& localView() const { return this->localView_; }
 
  LocalView& localView() { return this->localView_; }
};
} // namespace Ikarus