pathfollowing.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers ikarus@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <memory>
 
#include <ikarus/controlroutines/adaptivestepsizing.hh>
#include <ikarus/controlroutines/controlinfos.hh>
#include <ikarus/controlroutines/controlroutinebase.hh>
#include <ikarus/controlroutines/controlroutinefactory.hh>
#include <ikarus/controlroutines/pathfollowingfunctions.hh>
#include <ikarus/solver/nonlinearsolver/newtonraphsonwithscalarsubsidiaryfunction.hh>
#include <ikarus/solver/nonlinearsolver/nonlinearsolverfactory.hh>
#include <ikarus/utils/broadcaster/broadcastermessages.hh>
#include <ikarus/utils/differentiablefunctionfactory.hh>
 
namespace Ikarus {
 
template <typename D>
struct PathFollowingState
{
  using Domain = D;
 
  const Domain& domain;
  const ControlInformation& information;
  const SubsidiaryArgs& subsidiaryArgs;
 
  int loadStep{-1};
  double stepSize{};
};
 
namespace Impl {
  template <typename NLS, typename PF = ArcLength, typename ASS>
  consteval bool checkPathFollowingTemplates() {
    return Concepts::PathFollowingStrategy<PF, std::remove_cvref_t<NLS>, SubsidiaryArgs> and
           Concepts::AdaptiveStepSizingStrategy<ASS, NonLinearSolverInformation, SubsidiaryArgs,
                                                std::remove_cvref_t<typename NLS::DifferentiableFunction>> and
           Concepts::NonLinearSolverCheckForPathFollowing<NLS>;
  }
 
  template <typename F>
  struct PathFollowingStateFactory
  {
  private:
    using SignatureTraits = typename F::Traits;
    using Domain          = typename SignatureTraits::Domain;
 
  public:
    using type = PathFollowingState<Domain>;
  };
 
} // namespace Impl
 
template <typename F>
using PathFollowingStateType = Impl::PathFollowingStateFactory<F>::type;
 
template <typename NLS, typename PF, typename ASS>
requires(Impl::checkPathFollowingTemplates<NLS, PF, ASS>())
class PathFollowing;
 
template <typename PF_ = ArcLength, typename ASS_ = AdaptiveStepSizing::NoOp>
struct PathFollowingConfig
{
  using PF  = PF_;
  using ASS = ASS_;
 
  int steps{};
  double stepSize{};
  PF pathFollowingFunction{};
  ASS adaptiveStepSizingFunction{};
};
 
#ifndef DOXYGEN
PathFollowingConfig(int, double) -> PathFollowingConfig<>;
 
template <typename PF>
PathFollowingConfig(int, double, PF) -> PathFollowingConfig<PF>;
 
template <typename PF, typename ASS>
PathFollowingConfig(int, double, PF, ASS) -> PathFollowingConfig<PF, ASS>;
 
template <typename ASS>
PathFollowingConfig(int, double, ArcLength, ASS) -> PathFollowingConfig<ArcLength, ASS>;
#endif
 
template <typename NLS, typename PFConfig>
requires traits::isSpecialization<PathFollowingConfig, std::remove_cvref_t<PFConfig>>::value
auto createControlRoutine(PFConfig&& config, NLS&& nonlinearSolver) {
  return PathFollowing<typename std::remove_cvref_t<NLS>::element_type, typename PFConfig::PF, typename PFConfig::ASS>(
      std::forward<NLS>(nonlinearSolver), config.steps, config.stepSize, config.pathFollowingFunction,
      config.adaptiveStepSizingFunction);
}
 
template <typename NLS, typename PF = ArcLength, typename ASS = AdaptiveStepSizing::NoOp>
requires(Impl::checkPathFollowingTemplates<NLS, PF, ASS>())
class PathFollowing : public ControlRoutineBase<typename NLS::DifferentiableFunction,
                                                PathFollowingStateType<typename NLS::DifferentiableFunction>>
 
{
public:
  constexpr auto name() const { return std::string("Path following with " + pathFollowingType_.name()); }
 
  PathFollowing(const std::shared_ptr<NLS>& nls, int steps, double stepSize, PF pathFollowingType = ArcLength{},
                ASS adaptiveStepSizing = {})
      : nonLinearSolver_{nls},
        steps_{steps},
        stepSize_{stepSize},
        pathFollowingType_{pathFollowingType},
        adaptiveStepSizing_{adaptiveStepSizing} {
    if (steps_ <= 0)
      DUNE_THROW(Dune::InvalidStateException, "Number of steps should be greater than zero.");
  }
 
  [[nodiscard]] ControlInformation run(typename NLS::Domain& d);
 
  /* \brief returns the nonlinear solver */
  NLS& nonLinearSolver() { return *nonLinearSolver_; }
 
private:
  std::shared_ptr<NLS> nonLinearSolver_;
 
  int steps_;
  double stepSize_;
  PF pathFollowingType_;
  ASS adaptiveStepSizing_;
  SubsidiaryArgs subsidiaryArgs_;
 
  void updateAndNotifyControlInfo(ControlInformation& info, const NonLinearSolverInformation& solverInfo,
                                  const typename PathFollowing::State& state) {
    info.solverInfos.push_back(solverInfo);
    info.totalIterations += solverInfo.iterations;
    this->notify(ControlMessages::SOLUTION_CHANGED, state);
    this->notify(ControlMessages::STEP_ENDED, state);
  }
};
 
} // namespace Ikarus
 
#include <ikarus/controlroutines/pathfollowing.inl>