common.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <concepts>
 
#include <ikarus/solver/linearsolver/linearsolver.hh>
#include <ikarus/utils/defaultfunctions.hh>
#include <ikarus/utils/traits.hh>
 
namespace Ikarus {
 
namespace Concepts {
  template <typename NLS>
  concept HasValidIDBCForceFunction = not std::same_as<typename NLS::IDBCForceFunction, utils::IDBCForceDefault>;
} // namespace Concepts
 
template <typename NLS>
auto createSPDLinearSolverFromNonLinearSolver(const NLS& nls) {
  using JacobianType = std::remove_cvref_t<typename NLS::JacobianType>;
  static_assert((traits::isSpecializationTypeAndNonTypes<Eigen::Matrix, JacobianType>::value) or
                    (traits::isSpecializationTypeNonTypeAndType<Eigen::SparseMatrix, JacobianType>::value),
                "Linear solver not implemented for the chosen derivative type of the non-linear operator");
  SolverTypeTag solverTag;
 
  auto&& residual = nls.residual();
 
  if constexpr (traits::isSpecializationTypeAndNonTypes<Eigen::Matrix, JacobianType>::value)
    solverTag = SolverTypeTag::d_LDLT;
  else
    solverTag = SolverTypeTag::sd_SimplicialLDLT;
  return LinearSolver(solverTag);
}
 
template <typename NLS>
typename NLS::Domain::SolutionVectorType idbcIncrement(typename NLS::Domain& x, const NLS& nls, double Dlambda) {
  if constexpr (Concepts::HasValidIDBCForceFunction<NLS>) {
    auto y = x;
    y.parameter() += Dlambda;
    y.syncParameterAndGlobalSolution(nls.updateFunction());
    const auto delta = (y.globalSolution() - x.globalSolution()).eval();
    return delta;
  } else {
    Eigen::VectorXd v;
    v.setZero(x.globalSolution().size());
    return v;
  }
}
} // namespace Ikarus