SemiExplicit.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                                      *
 *                                                                                               *
 * The Sandals project is distributed under the BSD 2-Clause License.                            *
 *                                                                                               *
 * Davide Stocco                                                               Enrico Bertolazzi *
 * University of Trento                                                     University of Trento *
 * e-mail: davide.stocco@unitn.it                             e-mail: enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef SANDALS_SEMIEXPLICIT_SYSTEM_HH
#define SANDALS_SEMIEXPLICIT_SYSTEM_HH
 
#include <Sandals.hh>
#include <Sandals/System/Explicit.hh>
 
namespace Sandals {
 
  /*\
   |   ____                 _ _____            _ _      _ _
   |  / ___|  ___ _ __ ___ (_) ____|_  ___ __ | (_) ___(_) |_
   |  \___ \ / _ \ '_ ` _ \| |  _| \ \/ / '_ \| | |/ __| | __|
   |   ___) |  __/ | | | | | | |___ >  <| |_) | | | (__| | |_
   |  |____/ \___|_| |_| |_|_|_____/_/\_\ .__/|_|_|\___|_|\__|
   |                                    |_|
  \*/

  template <typename Real, Integer N, Integer M = 0>
  class SemiExplicit : public Explicit<Real, N, M>
  {
  public:
    SANDALS_BASIC_CONSTANTS(Real) 
 
    using Pointer = std::shared_ptr<SemiExplicit<Real, N, M>>; 
    using VectorF = typename Explicit<Real, N, M>::VectorF; 
    using MatrixJF = typename Explicit<Real, N, M>::MatrixJF; 
    using MatrixA = typename Explicit<Real, N, M>::MatrixJF; 
    using TensorTA = typename std::vector<MatrixJF>; 
    using VectorB = typename Explicit<Real, N, M>::VectorF; 
    using MatrixJB = typename Explicit<Real, N, M>::MatrixJF; 
    using Type = typename Explicit<Real, N, M>::Type; 
 
  private:
    mutable Eigen::FullPivLU<MatrixA> m_lu; 
 
  public:
    SemiExplicit() : Explicit<Real, N, M>(Type::SEMIEXPLICIT, "(missing name)") {}

    SemiExplicit(std::string t_name) : Explicit<Real, N, M>(Type::SEMIEXPLICIT, t_name) {}

    VectorF F(VectorF const &x, VectorF const &x_dot, Real t) const override
    {
      return this->A(x, t)*x_dot - this->b(x, t);
    }

    MatrixJF JF_x(VectorF const &x, VectorF const &x_dot, Real t) const override
    {
      return -this->Jf_x(x, x_dot, t);
    }

    MatrixJF JF_x_dot(VectorF const &x, VectorF const &/*x_dot*/, Real t) const override
    {
      return this->A(x, t);
    }

    VectorF f(VectorF const &x, Real t) const override
    {
      this->m_lu.compute(this->A(x, t));
      SANDALS_ASSERT(this->m_lu.rank() == N,
        "Sandals:SemiExplicit::f(...): singular mass matrix A detected.");
      return this->m_lu.solve(this->b(x, t));
    }

    MatrixJF Jf_x(VectorF const &x, VectorF const &x_dot, Real t) const
    {
      TensorTA TA_x{this->TA_x(x, t)};
      MatrixJF tAp{MatrixJF::Zero()};
      for (Integer i{0}; i < N; ++i) {tAp.col(i) = TA_x[i] * x_dot;} // TODO: Check if TA_x.size() = N
      this->m_lu.compute(this->A(x, t));
      SANDALS_ASSERT(this->m_lu.rank() == N,
        "Sandals:SemiExplicit::Jf_x(...): singular mass matrix A detected.");
      return this->m_lu.solve(this->Jb_x(x, t) - tAp);
    }

    MatrixJF Jf_x(VectorF const &x, Real t) const override {return this->Jf_x(x, this->f(x, t), t);}

    virtual MatrixA A(VectorF const &x, Real t) const = 0;

    virtual TensorTA TA_x(VectorF const &x, Real t) const = 0;

    virtual VectorB b(VectorF const &x, Real t) const = 0;

    virtual MatrixJB Jb_x(VectorF const &x, Real t) const = 0;
 
  }; // class SemiExplicit
 
  /*\
   |   ____                 _ _____            _ _      _ _ __        __
   |  / ___|  ___ _ __ ___ (_) ____|_  ___ __ | (_) ___(_) |\ \      / / __ __ _ _ __  _ __   ___ _ __
   |  \___ \ / _ \ '_ ` _ \| |  _| \ \/ / '_ \| | |/ __| | __\ \ /\ / / '__/ _` | '_ \| '_ \ / _ \ '__|
   |   ___) |  __/ | | | | | | |___ >  <| |_) | | | (__| | |_ \ V  V /| | | (_| | |_) | |_) |  __/ |
   |  |____/ \___|_| |_| |_|_|_____/_/\_\ .__/|_|_|\___|_|\__| \_/\_/ |_|  \__,_| .__/| .__/ \___|_|
   |                                    |_|                                     |_|   |_|
  \*/

  template <typename Real, Integer N, Integer M = 0>
  class SemiExplicitWrapper : public SemiExplicit<Real, N, M>
  {
  public:
    SANDALS_BASIC_CONSTANTS(Real) 
 
    using Pointer = std::shared_ptr<SemiExplicitWrapper<Real, N, M>>; 
    using VectorF = typename SemiExplicit<Real, N, M>::VectorF; 
    using MatrixA = typename SemiExplicit<Real, N, M>::MatrixA; 
    using TensorTA = typename SemiExplicit<Real, N, M>::TensorTA; 
    using VectorB = typename SemiExplicit<Real, N, M>::VectorB; 
    using MatrixJB = typename SemiExplicit<Real, N, M>::MatrixJB; 
    using VectorH = typename SemiExplicit<Real, N, M>::VectorH; 
    using MatrixJH = typename SemiExplicit<Real, N, M>::MatrixJH; 
    using FunctionA = std::function<MatrixA(VectorF const &, Real)>; 
    using FunctionTA = std::function<TensorTA(VectorF const &, Real)>; 
    using FunctionB = std::function<VectorB(VectorF const &, Real)>; 
    using FunctionJB = std::function<MatrixJB(VectorF const &, Real)>; 
    using FunctionH = std::function<VectorH(VectorF const &, Real)>; 
    using FunctionJH = std::function<MatrixJH(VectorF const &, Real)>; 
    using FunctionID = std::function<bool(VectorF const &, Real)>; 
 
    inline const static FunctionH DefaultH = [](VectorF const &, Real) {return VectorH::Zero();}; 
    inline const static FunctionJH DefaultJH = [](VectorF const &, Real) {return MatrixJH::Zero();}; 
    inline const static FunctionID DefaultID = [](VectorF const &, Real) {return true;}; 
 
  private:
    FunctionA m_A{nullptr}; 
    FunctionTA m_TA_x{nullptr}; 
    FunctionB m_b{nullptr}; 
    FunctionJB m_Jb_x{nullptr}; 
    FunctionH m_h{nullptr}; 
    FunctionJH m_Jh_x{nullptr}; 
    FunctionID m_in_domain{nullptr}; 
 
  public:
    SemiExplicitWrapper(FunctionA t_A, FunctionTA t_TA_x, FunctionB t_b, FunctionJB t_Jb_x,
      FunctionH t_h = DefaultH, FunctionJH t_Jh_x = DefaultJH, FunctionID t_in_domain = DefaultID)
      : SemiExplicit<Real, N, M>(), m_A(t_A), m_TA_x(t_TA_x), m_b(t_b), m_Jb_x(t_Jb_x), m_h(t_h),
      m_Jh_x(t_Jh_x), m_in_domain(t_in_domain)
    {}

    SemiExplicitWrapper(std::string t_name, FunctionA t_A, FunctionTA t_TA_x, FunctionB t_b, FunctionJB t_Jb_x,
      FunctionH t_h = DefaultH, FunctionJH t_Jh_x = DefaultJH, FunctionID t_in_domain = DefaultID)
      : SemiExplicit<Real, N, M>(t_name), m_A(t_A), m_TA_x(t_TA_x), m_b(t_b), m_Jb_x(t_Jb_x), m_h(t_h),
      m_Jh_x(t_Jh_x), m_in_domain(t_in_domain)
    {}

    ~SemiExplicitWrapper() {}

    FunctionA & A() {return this->m_A;}

    FunctionTA & TA_x() {return this->m_TA_x;}

    FunctionB & b() {return this->m_b;}

    FunctionJB & Jb_x() {return this->m_Jb_x;}

    FunctionH & h() {return this->m_h;}

    FunctionJH & Jh_x() {return this->m_Jh_x;}

    FunctionID & in_domain() {return this->m_in_domain;}

    MatrixA A(VectorF const &x, Real t) const override
    {
      return this->m_A(x, t);
    }

    TensorTA TA_x(VectorF const &x, Real t) const override
    {
      return this->m_TA_x(x, t);
    }

    VectorB b(VectorF const &x, Real t) const override
    {
      return this->m_b(x, t);
    }

    MatrixJB Jb_x(VectorF const &x, Real t) const override
    {
      return this->m_Jb_x(x, t);
    }
 

    VectorH h(VectorF const &x, Real t) const override
    {
      return this->m_h(x, t);
    }

    MatrixJH Jh_x(VectorF const &x, Real t) const override
    {
      return this->m_Jh_x(x, t);
    }

    bool in_domain(VectorF const &x, Real t) const override
    {
      return this->m_in_domain(x, t);
    }
 
  }; // class SemiExplicitWrapper
 
} // namespace Sandals
 
#endif // SANDALS_SEMIEXPLICIT_SYSTEM_HH